OMCompilerDoxygen
Functions
Absyn.c File Reference

Go to the source code of this file.

Functions

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpShallowIterator (threadData_t *threadData, modelica_metatype _inIterator, modelica_metatype _inArg, modelica_fnptr _inFunc)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpShallowFuncArgs (threadData_t *threadData, modelica_metatype _inArgs, modelica_metatype _inArg, modelica_fnptr _inFunc)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassDef (threadData_t *threadData, modelica_metatype _inClassDef, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseClassDef (threadData_t *threadData, modelica_metatype _inClassDef, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementSpecComponents (threadData_t *threadData, modelica_metatype _inSpec, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementSpecComponents (threadData_t *threadData, modelica_metatype _inSpec, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementComponents (threadData_t *threadData, modelica_metatype _inElement, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementComponents (threadData_t *threadData, modelica_metatype _inElement, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementItemComponents (threadData_t *threadData, modelica_metatype _inItem, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementItemComponents (threadData_t *threadData, modelica_metatype _inItem, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassPartComponents (threadData_t *threadData, modelica_metatype _inClassPart, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseClassPartComponents (threadData_t *threadData, modelica_metatype _inClassPart, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseListGeneric (threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseListGeneric (threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_metatype *out_outContinue)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getElementItemsInClassPart (threadData_t *threadData, modelica_metatype _inClassPart)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_dummyTraverseExp (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getNamedAnnotationStr (threadData_t *threadData, modelica_metatype _inAbsynElementArgLst, modelica_metatype _id, modelica_fnptr _f)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_mergeAnnotations2 (threadData_t *threadData, modelica_metatype _oldmods, modelica_metatype _newmods)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_isInitialTraverseHelper (threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _inBool, modelica_boolean *out_outBool)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_isInitialTraverseHelper (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inBool, modelica_metatype *out_outBool)
 
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_isExternalPart (threadData_t *threadData, modelica_metatype _inClassPart)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_isExternalPart (threadData_t *threadData, modelica_metatype _inClassPart)
 
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_filterAnnotationItem (threadData_t *threadData, modelica_metatype _elt)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_filterAnnotationItem (threadData_t *threadData, modelica_metatype _elt)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getFunctionInterfaceParts (threadData_t *threadData, modelica_metatype _part, modelica_metatype _elts)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_stripClassDefComment (threadData_t *threadData, modelica_metatype _cl)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_onlyLiteralsInExpExit (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inLst, modelica_metatype *out_outLst)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_onlyLiteralsInExpEnter (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inLst, modelica_metatype *out_outLst)
 
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_onlyLiteralsInEqMod (threadData_t *threadData, modelica_metatype _eqMod)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_onlyLiteralsInEqMod (threadData_t *threadData, modelica_metatype _eqMod)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getIteratorIndexedCrefs (threadData_t *threadData, modelica_metatype _inCref, modelica_string _inIterator, modelica_metatype _inCrefs)
 
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_iteratorIndexedCrefsEqual (threadData_t *threadData, modelica_metatype _inCref1, modelica_metatype _inCref2)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_iteratorIndexedCrefsEqual (threadData_t *threadData, modelica_metatype _inCref1, modelica_metatype _inCref2)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_findIteratorIndexedCrefs__traverser (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inCrefs, modelica_string _inIterator, modelica_metatype *out_outCrefs)
 
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_functionArgsEqual (threadData_t *threadData, modelica_metatype _args1, modelica_metatype _args2)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_functionArgsEqual (threadData_t *threadData, modelica_metatype _args1, modelica_metatype _args2)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getCrefFromNarg (threadData_t *threadData, modelica_metatype _inNamedArg, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_getCrefFromNarg (threadData_t *threadData, modelica_metatype _inNamedArg, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_pathToStringListWork (threadData_t *threadData, modelica_metatype _path, modelica_metatype _acc)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_stringListPathReversed2 (threadData_t *threadData, modelica_metatype _inStrings, modelica_metatype _inAccumPath)
 
PROTECTED_FUNCTION_STATIC modelica_string omc_Absyn_pathStringWork (threadData_t *threadData, modelica_metatype _inPath, modelica_integer _len, modelica_string _delimiter, modelica_integer _dlen, modelica_boolean _reverse)
 
PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_pathStringWork (threadData_t *threadData, modelica_metatype _inPath, modelica_metatype _len, modelica_metatype _delimiter, modelica_metatype _dlen, modelica_metatype _reverse)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmBidir (threadData_t *threadData, modelica_metatype _inAlg, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmBidirElse (threadData_t *threadData, modelica_metatype _inElse, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationBidirElse (threadData_t *threadData, modelica_metatype _inElse, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemBidir (threadData_t *threadData, modelica_metatype _inEquationItem, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmItemBidir (threadData_t *threadData, modelica_metatype _inAlgorithmItem, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmItemListBidir (threadData_t *threadData, modelica_metatype _inAlgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemListBidir (threadData_t *threadData, modelica_metatype _inEquationItems, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassPartBidir (threadData_t *threadData, modelica_metatype _cp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpBidirSubExps (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
 
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItem (threadData_t *threadData, modelica_metatype _inEquationItem, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
 
DLLExport modelica_integer omc_Absyn_pathPartCount (threadData_t *threadData, modelica_metatype _path, modelica_integer _partsAccum)
 
modelica_metatype boxptr_Absyn_pathPartCount (threadData_t *threadData, modelica_metatype _path, modelica_metatype _partsAccum)
 
DLLExport modelica_metatype omc_Absyn_isInvariantExpNoTraverse (threadData_t *threadData, modelica_metatype _ $in_e, modelica_boolean _ $in_b, modelica_boolean *out_b)
 
modelica_metatype boxptr_Absyn_isInvariantExpNoTraverse (threadData_t *threadData, modelica_metatype _ $in_e, modelica_metatype _ $in_b, modelica_metatype *out_b)
 
DLLExport modelica_boolean omc_Absyn_isEmptyClassPart (threadData_t *threadData, modelica_metatype _inClassPart)
 
modelica_metatype boxptr_Absyn_isEmptyClassPart (threadData_t *threadData, modelica_metatype _inClassPart)
 
DLLExport modelica_boolean omc_Absyn_isElementItemClassNamed (threadData_t *threadData, modelica_string _inName, modelica_metatype _inElement)
 
modelica_metatype boxptr_Absyn_isElementItemClassNamed (threadData_t *threadData, modelica_metatype _inName, modelica_metatype _inElement)
 
DLLExport modelica_boolean omc_Absyn_isAlgorithmItem (threadData_t *threadData, modelica_metatype _inAlg)
 
modelica_metatype boxptr_Absyn_isAlgorithmItem (threadData_t *threadData, modelica_metatype _inAlg)
 
DLLExport modelica_boolean omc_Absyn_isElementItem (threadData_t *threadData, modelica_metatype _inElement)
 
modelica_metatype boxptr_Absyn_isElementItem (threadData_t *threadData, modelica_metatype _inElement)
 
DLLExport modelica_boolean omc_Absyn_isElementItemClass (threadData_t *threadData, modelica_metatype _inElement)
 
modelica_metatype boxptr_Absyn_isElementItemClass (threadData_t *threadData, modelica_metatype _inElement)
 
DLLExport modelica_metatype omc_Absyn_traverseExpShallow (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inArg, modelica_fnptr _inFunc)
 
DLLExport modelica_metatype omc_Absyn_crefExplode (threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inAccum)
 
DLLExport modelica_metatype omc_Absyn_makeSubscript (threadData_t *threadData, modelica_metatype _inExp)
 
DLLExport modelica_metatype omc_Absyn_optMsg (threadData_t *threadData, modelica_boolean _inShowMessage, modelica_metatype _inInfo)
 
modelica_metatype boxptr_Absyn_optMsg (threadData_t *threadData, modelica_metatype _inShowMessage, modelica_metatype _inInfo)
 
DLLExport modelica_boolean omc_Absyn_elementArgEqualName (threadData_t *threadData, modelica_metatype _inArg1, modelica_metatype _inArg2)
 
modelica_metatype boxptr_Absyn_elementArgEqualName (threadData_t *threadData, modelica_metatype _inArg1, modelica_metatype _inArg2)
 
DLLExport modelica_metatype omc_Absyn_elementArgName (threadData_t *threadData, modelica_metatype _inArg)
 
DLLExport modelica_boolean omc_Absyn_isEmptySubMod (threadData_t *threadData, modelica_metatype _inSubMod)
 
modelica_metatype boxptr_Absyn_isEmptySubMod (threadData_t *threadData, modelica_metatype _inSubMod)
 
DLLExport modelica_boolean omc_Absyn_isEmptyMod (threadData_t *threadData, modelica_metatype _inMod)
 
modelica_metatype boxptr_Absyn_isEmptyMod (threadData_t *threadData, modelica_metatype _inMod)
 
DLLExport modelica_metatype omc_Absyn_traverseClassComponents (threadData_t *threadData, modelica_metatype _inClass, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_getElementItemsInClass (threadData_t *threadData, modelica_metatype _inClass)
 
DLLExport modelica_metatype omc_Absyn_getDefineUnitsInElements (threadData_t *threadData, modelica_metatype _elts)
 
DLLExport modelica_boolean omc_Absyn_opIsElementWise (threadData_t *threadData, modelica_metatype _op)
 
modelica_metatype boxptr_Absyn_opIsElementWise (threadData_t *threadData, modelica_metatype _op)
 
DLLExport modelica_boolean omc_Absyn_opEqual (threadData_t *threadData, modelica_metatype _op1, modelica_metatype _op2)
 
modelica_metatype boxptr_Absyn_opEqual (threadData_t *threadData, modelica_metatype _op1, modelica_metatype _op2)
 
DLLExport modelica_metatype omc_Absyn_mapCrefParts (threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _inMapFunc)
 
DLLExport modelica_metatype omc_Absyn_getNamedAnnotationInClass (threadData_t *threadData, modelica_metatype _inClass, modelica_metatype _id, modelica_fnptr _f)
 
DLLExport modelica_metatype omc_Absyn_removeCrefFromCrefs (threadData_t *threadData, modelica_metatype _inAbsynComponentRefLst, modelica_metatype _inComponentRef)
 
DLLExport modelica_metatype omc_Absyn_getArrayDimOptAsList (threadData_t *threadData, modelica_metatype _inArrayDim)
 
DLLExport modelica_string omc_Absyn_refStringBrief (threadData_t *threadData, modelica_metatype _inRef)
 
DLLExport modelica_string omc_Absyn_refString (threadData_t *threadData, modelica_metatype _inRef)
 
DLLExport modelica_string omc_Absyn_importString (threadData_t *threadData, modelica_metatype _inImp)
 
DLLExport modelica_string omc_Absyn_crefStringIgnoreSubs (threadData_t *threadData, modelica_metatype _inCr)
 
DLLExport modelica_string omc_Absyn_typeSpecStringNoQualNoDimsLst (threadData_t *threadData, modelica_metatype _inTypeSpecLst)
 
DLLExport modelica_string omc_Absyn_typeSpecStringNoQualNoDims (threadData_t *threadData, modelica_metatype _inTs)
 
DLLExport modelica_string omc_Absyn_crefString (threadData_t *threadData, modelica_metatype _inCr)
 
DLLExport modelica_string omc_Absyn_typeSpecString (threadData_t *threadData, modelica_metatype _inTs)
 
DLLExport modelica_metatype omc_Absyn_pathToTypeSpec (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_annotationToElementArgs (threadData_t *threadData, modelica_metatype _ann)
 
DLLExport modelica_metatype omc_Absyn_subModsInSameOrder (threadData_t *threadData, modelica_metatype _oldmod, modelica_metatype _newmod)
 
DLLExport modelica_boolean omc_Absyn_isModificationOfPath (threadData_t *threadData, modelica_metatype _mod, modelica_metatype _path)
 
modelica_metatype boxptr_Absyn_isModificationOfPath (threadData_t *threadData, modelica_metatype _mod, modelica_metatype _path)
 
DLLExport modelica_metatype omc_Absyn_mergeCommentAnnotation (threadData_t *threadData, modelica_metatype _inAnnotation, modelica_metatype _inComment)
 
DLLExport modelica_metatype omc_Absyn_mergeAnnotations (threadData_t *threadData, modelica_metatype _inAnnotation1, modelica_metatype _inAnnotation2)
 
DLLExport modelica_string omc_Absyn_importName (threadData_t *threadData, modelica_metatype _inImport)
 
DLLExport modelica_metatype omc_Absyn_importPath (threadData_t *threadData, modelica_metatype _inImport)
 
DLLExport modelica_boolean omc_Absyn_isInitial (threadData_t *threadData, modelica_metatype _inExp)
 
modelica_metatype boxptr_Absyn_isInitial (threadData_t *threadData, modelica_metatype _inExp)
 
DLLExport modelica_boolean omc_Absyn_expContainsInitial (threadData_t *threadData, modelica_metatype _inExp)
 
modelica_metatype boxptr_Absyn_expContainsInitial (threadData_t *threadData, modelica_metatype _inExp)
 
DLLExport modelica_metatype omc_Absyn_pathSetLastIdent (threadData_t *threadData, modelica_metatype _inPath, modelica_metatype _inLastIdent)
 
DLLExport modelica_string omc_Absyn_componentName (threadData_t *threadData, modelica_metatype _c)
 
DLLExport modelica_metatype omc_Absyn_makeClassElement (threadData_t *threadData, modelica_metatype _cl)
 
DLLExport modelica_boolean omc_Absyn_isParts (threadData_t *threadData, modelica_metatype _cl)
 
modelica_metatype boxptr_Absyn_isParts (threadData_t *threadData, modelica_metatype _cl)
 
DLLExport modelica_metatype omc_Absyn_getExternalDecl (threadData_t *threadData, modelica_metatype _inCls)
 
DLLExport modelica_metatype omc_Absyn_getFunctionInterface (threadData_t *threadData, modelica_metatype _cl)
 
DLLExport modelica_metatype omc_Absyn_getShortClass (threadData_t *threadData, modelica_metatype _cl)
 
DLLExport modelica_boolean omc_Absyn_pathGe (threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
 
modelica_metatype boxptr_Absyn_pathGe (threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
 
DLLExport modelica_boolean omc_Absyn_pathLt (threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
 
modelica_metatype boxptr_Absyn_pathLt (threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
 
DLLExport modelica_boolean omc_Absyn_isFieldEqual (threadData_t *threadData, modelica_metatype _isField1, modelica_metatype _isField2)
 
modelica_metatype boxptr_Absyn_isFieldEqual (threadData_t *threadData, modelica_metatype _isField1, modelica_metatype _isField2)
 
DLLExport modelica_boolean omc_Absyn_directionEqual (threadData_t *threadData, modelica_metatype _inDirection1, modelica_metatype _inDirection2)
 
modelica_metatype boxptr_Absyn_directionEqual (threadData_t *threadData, modelica_metatype _inDirection1, modelica_metatype _inDirection2)
 
DLLExport modelica_boolean omc_Absyn_isOutput (threadData_t *threadData, modelica_metatype _inDirection)
 
modelica_metatype boxptr_Absyn_isOutput (threadData_t *threadData, modelica_metatype _inDirection)
 
DLLExport modelica_boolean omc_Absyn_isInput (threadData_t *threadData, modelica_metatype _inDirection)
 
modelica_metatype boxptr_Absyn_isInput (threadData_t *threadData, modelica_metatype _inDirection)
 
DLLExport modelica_boolean omc_Absyn_isInputOrOutput (threadData_t *threadData, modelica_metatype _direction)
 
modelica_metatype boxptr_Absyn_isInputOrOutput (threadData_t *threadData, modelica_metatype _direction)
 
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim__tail (threadData_t *threadData, modelica_metatype _inAd, modelica_metatype _inAccumulator, modelica_metatype *out_outExps)
 
modelica_metatype boxptr_Absyn_getExpsFromArrayDim__tail (threadData_t *threadData, modelica_metatype _inAd, modelica_metatype _inAccumulator, modelica_metatype *out_outExps)
 
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDimOpt (threadData_t *threadData, modelica_metatype _inAdO, modelica_metatype *out_outExps)
 
modelica_metatype boxptr_Absyn_getExpsFromArrayDimOpt (threadData_t *threadData, modelica_metatype _inAdO, modelica_metatype *out_outExps)
 
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim (threadData_t *threadData, modelica_metatype _inAd, modelica_metatype *out_outExps)
 
modelica_metatype boxptr_Absyn_getExpsFromArrayDim (threadData_t *threadData, modelica_metatype _inAd, modelica_metatype *out_outExps)
 
DLLExport void omc_Absyn_isDerCrefFail (threadData_t *threadData, modelica_metatype _exp)
 
DLLExport modelica_boolean omc_Absyn_isDerCref (threadData_t *threadData, modelica_metatype _exp)
 
modelica_metatype boxptr_Absyn_isDerCref (threadData_t *threadData, modelica_metatype _exp)
 
DLLExport modelica_boolean omc_Absyn_isTuple (threadData_t *threadData, modelica_metatype _inExp)
 
modelica_metatype boxptr_Absyn_isTuple (threadData_t *threadData, modelica_metatype _inExp)
 
DLLExport modelica_boolean omc_Absyn_isCref (threadData_t *threadData, modelica_metatype _exp)
 
modelica_metatype boxptr_Absyn_isCref (threadData_t *threadData, modelica_metatype _exp)
 
DLLExport modelica_metatype omc_Absyn_crefInsertSubscriptLstLst2 (threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inSubs)
 
DLLExport modelica_metatype omc_Absyn_crefInsertSubscriptLstLst (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _inLst, modelica_metatype *out_outLst)
 
DLLExport modelica_metatype omc_Absyn_subscriptExpOpt (threadData_t *threadData, modelica_metatype _inSub)
 
DLLExport modelica_string omc_Absyn_innerOuterStr (threadData_t *threadData, modelica_metatype _io)
 
DLLExport modelica_metatype omc_Absyn_joinWithinPath (threadData_t *threadData, modelica_metatype _within_, modelica_metatype _path)
 
DLLExport modelica_string omc_Absyn_withinString (threadData_t *threadData, modelica_metatype _w1)
 
DLLExport modelica_boolean omc_Absyn_withinEqual (threadData_t *threadData, modelica_metatype _within1, modelica_metatype _within2)
 
modelica_metatype boxptr_Absyn_withinEqual (threadData_t *threadData, modelica_metatype _within1, modelica_metatype _within2)
 
DLLExport modelica_boolean omc_Absyn_pathIsQual (threadData_t *threadData, modelica_metatype _inPath)
 
modelica_metatype boxptr_Absyn_pathIsQual (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_boolean omc_Absyn_pathIsIdent (threadData_t *threadData, modelica_metatype _inPath)
 
modelica_metatype boxptr_Absyn_pathIsIdent (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_boolean omc_Absyn_pathIsFullyQualified (threadData_t *threadData, modelica_metatype _inPath)
 
modelica_metatype boxptr_Absyn_pathIsFullyQualified (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_unqualifyCref (threadData_t *threadData, modelica_metatype _inCref)
 
DLLExport modelica_metatype omc_Absyn_unqotePathIdents (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_string omc_Absyn_crefIdent (threadData_t *threadData, modelica_metatype _cr)
 
DLLExport modelica_metatype omc_Absyn_makeCons (threadData_t *threadData, modelica_metatype _e1, modelica_metatype _e2)
 
DLLExport modelica_boolean omc_Absyn_onlyLiteralsInAnnotationMod (threadData_t *threadData, modelica_metatype _inMod)
 
modelica_metatype boxptr_Absyn_onlyLiteralsInAnnotationMod (threadData_t *threadData, modelica_metatype _inMod)
 
DLLExport modelica_metatype omc_Absyn_canonIfExp (threadData_t *threadData, modelica_metatype _inExp)
 
DLLExport modelica_boolean omc_Absyn_importEqual (threadData_t *threadData, modelica_metatype _im1, modelica_metatype _im2)
 
modelica_metatype boxptr_Absyn_importEqual (threadData_t *threadData, modelica_metatype _im1, modelica_metatype _im2)
 
DLLExport modelica_metatype omc_Absyn_makeNotFullyQualified (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_makeFullyQualified (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_boolean omc_Absyn_innerOuterEqual (threadData_t *threadData, modelica_metatype _io1, modelica_metatype _io2)
 
modelica_metatype boxptr_Absyn_innerOuterEqual (threadData_t *threadData, modelica_metatype _io1, modelica_metatype _io2)
 
DLLExport modelica_boolean omc_Absyn_isNotInnerOuter (threadData_t *threadData, modelica_metatype _inIO)
 
modelica_metatype boxptr_Absyn_isNotInnerOuter (threadData_t *threadData, modelica_metatype _inIO)
 
DLLExport modelica_boolean omc_Absyn_isInnerOuter (threadData_t *threadData, modelica_metatype _inIO)
 
modelica_metatype boxptr_Absyn_isInnerOuter (threadData_t *threadData, modelica_metatype _inIO)
 
DLLExport modelica_boolean omc_Absyn_isOnlyOuter (threadData_t *threadData, modelica_metatype _inIO)
 
modelica_metatype boxptr_Absyn_isOnlyOuter (threadData_t *threadData, modelica_metatype _inIO)
 
DLLExport modelica_boolean omc_Absyn_isOnlyInner (threadData_t *threadData, modelica_metatype _inIO)
 
modelica_metatype boxptr_Absyn_isOnlyInner (threadData_t *threadData, modelica_metatype _inIO)
 
DLLExport modelica_boolean omc_Absyn_isInner (threadData_t *threadData, modelica_metatype _io)
 
modelica_metatype boxptr_Absyn_isInner (threadData_t *threadData, modelica_metatype _io)
 
DLLExport modelica_boolean omc_Absyn_isOuter (threadData_t *threadData, modelica_metatype _io)
 
modelica_metatype boxptr_Absyn_isOuter (threadData_t *threadData, modelica_metatype _io)
 
DLLExport modelica_string omc_Absyn_getFileNameFromInfo (threadData_t *threadData, modelica_metatype _inInfo)
 
DLLExport modelica_metatype omc_Absyn_pathReplaceIdent (threadData_t *threadData, modelica_metatype _path, modelica_string _last)
 
DLLExport modelica_metatype omc_Absyn_findIteratorIndexedCrefs (threadData_t *threadData, modelica_metatype _inExp, modelica_string _inIterator, modelica_metatype _inCrefs)
 
DLLExport modelica_string omc_Absyn_getClassName (threadData_t *threadData, modelica_metatype _inClass)
 
DLLExport modelica_boolean omc_Absyn_eachEqual (threadData_t *threadData, modelica_metatype _each1, modelica_metatype _each2)
 
modelica_metatype boxptr_Absyn_eachEqual (threadData_t *threadData, modelica_metatype _each1, modelica_metatype _each2)
 
DLLExport modelica_boolean omc_Absyn_expEqual (threadData_t *threadData, modelica_metatype _exp1, modelica_metatype _exp2)
 
modelica_metatype boxptr_Absyn_expEqual (threadData_t *threadData, modelica_metatype _exp1, modelica_metatype _exp2)
 
DLLExport modelica_boolean omc_Absyn_isFunctionRestriction (threadData_t *threadData, modelica_metatype _inRestriction)
 
modelica_metatype boxptr_Absyn_isFunctionRestriction (threadData_t *threadData, modelica_metatype _inRestriction)
 
DLLExport modelica_boolean omc_Absyn_isPackageRestriction (threadData_t *threadData, modelica_metatype _inRestriction)
 
modelica_metatype boxptr_Absyn_isPackageRestriction (threadData_t *threadData, modelica_metatype _inRestriction)
 
DLLExport modelica_boolean omc_Absyn_crefEqualNoSubs (threadData_t *threadData, modelica_metatype _cr1, modelica_metatype _cr2)
 
modelica_metatype boxptr_Absyn_crefEqualNoSubs (threadData_t *threadData, modelica_metatype _cr1, modelica_metatype _cr2)
 
DLLExport modelica_boolean omc_Absyn_subscriptsEqual (threadData_t *threadData, modelica_metatype _inSubList1, modelica_metatype _inSubList2)
 
modelica_metatype boxptr_Absyn_subscriptsEqual (threadData_t *threadData, modelica_metatype _inSubList1, modelica_metatype _inSubList2)
 
DLLExport modelica_boolean omc_Absyn_subscriptEqual (threadData_t *threadData, modelica_metatype _inSubscript1, modelica_metatype _inSubscript2)
 
modelica_metatype boxptr_Absyn_subscriptEqual (threadData_t *threadData, modelica_metatype _inSubscript1, modelica_metatype _inSubscript2)
 
DLLExport modelica_boolean omc_Absyn_crefFirstEqual (threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
 
modelica_metatype boxptr_Absyn_crefFirstEqual (threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
 
DLLExport modelica_boolean omc_Absyn_crefEqual (threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
 
modelica_metatype boxptr_Absyn_crefEqual (threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
 
DLLExport modelica_metatype omc_Absyn_setClassBody (threadData_t *threadData, modelica_metatype _inClass, modelica_metatype _inBody)
 
DLLExport modelica_metatype omc_Absyn_setClassName (threadData_t *threadData, modelica_metatype _inClass, modelica_string _newName)
 
DLLExport modelica_metatype omc_Absyn_setClassFilename (threadData_t *threadData, modelica_metatype _inClass, modelica_string _fileName)
 
DLLExport modelica_string omc_Absyn_classFilename (threadData_t *threadData, modelica_metatype _inClass)
 
DLLExport modelica_metatype omc_Absyn_lastClassname (threadData_t *threadData, modelica_metatype _inProgram)
 
DLLExport modelica_string omc_Absyn_restrString (threadData_t *threadData, modelica_metatype _inRestriction)
 
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_boolean omc_Absyn_crefIsFullyQualified (threadData_t *threadData, modelica_metatype _inCref)
 
modelica_metatype boxptr_Absyn_crefIsFullyQualified (threadData_t *threadData, modelica_metatype _inCref)
 
DLLExport modelica_metatype omc_Absyn_crefStripFirst (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_metatype omc_Absyn_crefFirstCref (threadData_t *threadData, modelica_metatype _inCref)
 
DLLExport modelica_string omc_Absyn_crefSecondIdent (threadData_t *threadData, modelica_metatype _cref)
 
DLLExport modelica_string omc_Absyn_crefFirstIdent (threadData_t *threadData, modelica_metatype _inCref)
 
DLLExport modelica_metatype omc_Absyn_joinCrefs (threadData_t *threadData, modelica_metatype _inComponentRef1, modelica_metatype _inComponentRef2)
 
DLLExport modelica_metatype omc_Absyn_crefStripLastSubs (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_metatype omc_Absyn_crefGetLastIdent (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_metatype omc_Absyn_getSubsFromCref (threadData_t *threadData, modelica_metatype _cr, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
 
modelica_metatype boxptr_Absyn_getSubsFromCref (threadData_t *threadData, modelica_metatype _cr, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
 
DLLExport modelica_boolean omc_Absyn_crefHasSubscripts (threadData_t *threadData, modelica_metatype _cref)
 
modelica_metatype boxptr_Absyn_crefHasSubscripts (threadData_t *threadData, modelica_metatype _cref)
 
DLLExport modelica_metatype omc_Absyn_crefSetLastSubs (threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inSubscripts)
 
DLLExport modelica_metatype omc_Absyn_crefLastSubs (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_boolean omc_Absyn_crefIsQual (threadData_t *threadData, modelica_metatype _inComponentRef)
 
modelica_metatype boxptr_Absyn_crefIsQual (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_boolean omc_Absyn_crefIsIdent (threadData_t *threadData, modelica_metatype _inComponentRef)
 
modelica_metatype boxptr_Absyn_crefIsIdent (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_string omc_Absyn_crefFirstIdentNoSubs (threadData_t *threadData, modelica_metatype _inCref)
 
DLLExport modelica_string omc_Absyn_crefLastIdent (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_metatype omc_Absyn_pathToCrefWithSubs (threadData_t *threadData, modelica_metatype _inPath, modelica_metatype _inSubs)
 
DLLExport modelica_metatype omc_Absyn_pathToCref (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_crefToPathIgnoreSubs (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_metatype omc_Absyn_elementSpecToPath (threadData_t *threadData, modelica_metatype _inElementSpec)
 
DLLExport modelica_metatype omc_Absyn_crefToPath (threadData_t *threadData, modelica_metatype _inComponentRef)
 
DLLExport modelica_metatype omc_Absyn_stripFirst (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_splitQualAndIdentPath (threadData_t *threadData, modelica_metatype _inPath, modelica_metatype *out_outPath2)
 
DLLExport modelica_metatype omc_Absyn_crefStripLast (threadData_t *threadData, modelica_metatype _inCref)
 
DLLExport modelica_metatype omc_Absyn_stripLastOpt (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_stripLast (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_pathAppendList (threadData_t *threadData, modelica_metatype _inPathLst)
 
DLLExport modelica_metatype omc_Absyn_selectPathsOpt (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
 
DLLExport modelica_metatype omc_Absyn_joinPathsOptSuffix (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
 
DLLExport modelica_metatype omc_Absyn_joinPathsOpt (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
 
DLLExport modelica_metatype omc_Absyn_joinPaths (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
 
DLLExport modelica_metatype omc_Absyn_getNamedFuncArgNamesAndValues (threadData_t *threadData, modelica_metatype _inNamedArgList, modelica_metatype *out_outExpList)
 
DLLExport modelica_metatype omc_Absyn_iteratorGuard (threadData_t *threadData, modelica_metatype _iterator)
 
DLLExport modelica_metatype omc_Absyn_iteratorRange (threadData_t *threadData, modelica_metatype _iterator)
 
DLLExport modelica_string omc_Absyn_iteratorName (threadData_t *threadData, modelica_metatype _iterator)
 
DLLExport modelica_metatype omc_Absyn_getCrefFromFarg (threadData_t *threadData, modelica_metatype _inFunctionArgs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
 
modelica_metatype boxptr_Absyn_getCrefFromFarg (threadData_t *threadData, modelica_metatype _inFunctionArgs, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
 
DLLExport modelica_metatype omc_Absyn_getCrefFromExp (threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
 
modelica_metatype boxptr_Absyn_getCrefFromExp (threadData_t *threadData, modelica_metatype _inExp, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
 
DLLExport modelica_metatype omc_Absyn_getCrefsFromSubs (threadData_t *threadData, modelica_metatype _isubs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
 
modelica_metatype boxptr_Absyn_getCrefsFromSubs (threadData_t *threadData, modelica_metatype _isubs, modelica_metatype _includeSubs, modelica_metatype _includeFunctions)
 
DLLExport modelica_metatype omc_Absyn_pathContainedIn (threadData_t *threadData, modelica_metatype _subPath, modelica_metatype _path)
 
DLLExport modelica_boolean omc_Absyn_pathContainsString (threadData_t *threadData, modelica_metatype _p1, modelica_string _str)
 
modelica_metatype boxptr_Absyn_pathContainsString (threadData_t *threadData, modelica_metatype _p1, modelica_metatype _str)
 
DLLExport modelica_boolean omc_Absyn_pathContains (threadData_t *threadData, modelica_metatype _fullPath, modelica_metatype _pathId)
 
modelica_metatype boxptr_Absyn_pathContains (threadData_t *threadData, modelica_metatype _fullPath, modelica_metatype _pathId)
 
DLLExport modelica_metatype omc_Absyn_crefRemovePrefix (threadData_t *threadData, modelica_metatype _prefixCr, modelica_metatype _cr)
 
DLLExport modelica_metatype omc_Absyn_removePartialPrefix (threadData_t *threadData, modelica_metatype _inPrefix, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_removePrefix (threadData_t *threadData, modelica_metatype _prefix_path, modelica_metatype _path)
 
DLLExport modelica_boolean omc_Absyn_crefPrefixOf (threadData_t *threadData, modelica_metatype _prefixCr, modelica_metatype _cr)
 
modelica_metatype boxptr_Absyn_crefPrefixOf (threadData_t *threadData, modelica_metatype _prefixCr, modelica_metatype _cr)
 
DLLExport modelica_boolean omc_Absyn_pathPrefixOf (threadData_t *threadData, modelica_metatype _prefixPath, modelica_metatype _path)
 
modelica_metatype boxptr_Absyn_pathPrefixOf (threadData_t *threadData, modelica_metatype _prefixPath, modelica_metatype _path)
 
DLLExport modelica_metatype omc_Absyn_crefReplaceFirstIdent (threadData_t *threadData, modelica_metatype _icref, modelica_metatype _replPath)
 
DLLExport modelica_metatype omc_Absyn_addSubscriptsLast (threadData_t *threadData, modelica_metatype _icr, modelica_metatype _i)
 
DLLExport modelica_metatype omc_Absyn_pathReplaceFirstIdent (threadData_t *threadData, modelica_metatype _path, modelica_metatype _replPath)
 
DLLExport modelica_metatype omc_Absyn_pathToStringList (threadData_t *threadData, modelica_metatype _path)
 
DLLExport modelica_boolean omc_Absyn_pathSuffixOfr (threadData_t *threadData, modelica_metatype _path, modelica_metatype _suffix_path)
 
modelica_metatype boxptr_Absyn_pathSuffixOfr (threadData_t *threadData, modelica_metatype _path, modelica_metatype _suffix_path)
 
DLLExport modelica_boolean omc_Absyn_pathSuffixOf (threadData_t *threadData, modelica_metatype _suffix_path, modelica_metatype _path)
 
modelica_metatype boxptr_Absyn_pathSuffixOf (threadData_t *threadData, modelica_metatype _suffix_path, modelica_metatype _path)
 
DLLExport modelica_metatype omc_Absyn_suffixPath (threadData_t *threadData, modelica_metatype _inPath, modelica_string _inSuffix)
 
DLLExport modelica_metatype omc_Absyn_prefixOptPath (threadData_t *threadData, modelica_string _prefix, modelica_metatype _optPath)
 
DLLExport modelica_metatype omc_Absyn_prefixPath (threadData_t *threadData, modelica_string _prefix, modelica_metatype _path)
 
DLLExport modelica_metatype omc_Absyn_pathPrefix (threadData_t *threadData, modelica_metatype _path)
 
DLLExport modelica_metatype omc_Absyn_pathStripSamePrefix (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
 
DLLExport modelica_metatype omc_Absyn_pathRest (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_string omc_Absyn_pathSecondIdent (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_pathFirstPath (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_string omc_Absyn_pathFirstIdent (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_pathLast (threadData_t *threadData, modelica_metatype _ $in_path)
 
DLLExport modelica_string omc_Absyn_pathLastIdent (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_pathTwoLastIdents (threadData_t *threadData, modelica_metatype _inPath)
 
DLLExport modelica_metatype omc_Absyn_stringListPathReversed (threadData_t *threadData, modelica_metatype _inStrings)
 
DLLExport modelica_metatype omc_Absyn_stringListPath (threadData_t *threadData, modelica_metatype _paths)
 
DLLExport modelica_metatype omc_Absyn_stringPath (threadData_t *threadData, modelica_string _str)
 
DLLExport modelica_string omc_Absyn_pathStringUnquoteReplaceDot (threadData_t *threadData, modelica_metatype _inPath, modelica_string _repStr)
 
DLLExport modelica_string omc_Absyn_optPathString (threadData_t *threadData, modelica_metatype _inPathOption)
 
DLLExport modelica_integer omc_Absyn_pathHashModWork (threadData_t *threadData, modelica_metatype _path, modelica_integer _acc)
 
modelica_metatype boxptr_Absyn_pathHashModWork (threadData_t *threadData, modelica_metatype _path, modelica_metatype _acc)
 
DLLExport modelica_integer omc_Absyn_pathHashMod (threadData_t *threadData, modelica_metatype _path, modelica_integer _mod)
 
modelica_metatype boxptr_Absyn_pathHashMod (threadData_t *threadData, modelica_metatype _path, modelica_metatype _mod)
 
DLLExport modelica_integer omc_Absyn_pathCompareNoQual (threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
 
modelica_metatype boxptr_Absyn_pathCompareNoQual (threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
 
DLLExport modelica_integer omc_Absyn_pathCompare (threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
 
modelica_metatype boxptr_Absyn_pathCompare (threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
 
DLLExport modelica_boolean omc_Absyn_classNameGreater (threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
 
modelica_metatype boxptr_Absyn_classNameGreater (threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
 
DLLExport modelica_integer omc_Absyn_classNameCompare (threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
 
modelica_metatype boxptr_Absyn_classNameCompare (threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
 
DLLExport modelica_string omc_Absyn_pathStringDefault (threadData_t *threadData, modelica_metatype _path)
 
DLLExport modelica_string omc_Absyn_pathStringNoQual (threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
 
modelica_metatype boxptr_Absyn_pathStringNoQual (threadData_t *threadData, modelica_metatype _path, modelica_metatype _delimiter, modelica_metatype _usefq, modelica_metatype _reverse)
 
DLLExport modelica_string omc_Absyn_pathString (threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
 
modelica_metatype boxptr_Absyn_pathString (threadData_t *threadData, modelica_metatype _path, modelica_metatype _delimiter, modelica_metatype _usefq, modelica_metatype _reverse)
 
DLLExport modelica_metatype omc_Absyn_typeSpecDimensions (threadData_t *threadData, modelica_metatype _inTypeSpec)
 
DLLExport modelica_metatype omc_Absyn_typeSpecPath (threadData_t *threadData, modelica_metatype _tp)
 
DLLExport modelica_string omc_Absyn_typeSpecPathString (threadData_t *threadData, modelica_metatype _tp)
 
DLLExport modelica_boolean omc_Absyn_optArrayDimEqual (threadData_t *threadData, modelica_metatype _oad1, modelica_metatype _oad2)
 
modelica_metatype boxptr_Absyn_optArrayDimEqual (threadData_t *threadData, modelica_metatype _oad1, modelica_metatype _oad2)
 
DLLExport modelica_boolean omc_Absyn_typeSpecEqual (threadData_t *threadData, modelica_metatype _a, modelica_metatype _b)
 
modelica_metatype boxptr_Absyn_typeSpecEqual (threadData_t *threadData, modelica_metatype _a, modelica_metatype _b)
 
DLLExport modelica_boolean omc_Absyn_pathEqual (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
 
modelica_metatype boxptr_Absyn_pathEqual (threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
 
DLLExport modelica_string omc_Absyn_printComponentRefStr (threadData_t *threadData, modelica_metatype _cr)
 
DLLExport modelica_string omc_Absyn_expComponentRefStr (threadData_t *threadData, modelica_metatype _aexp)
 
DLLExport modelica_metatype omc_Absyn_crefExp (threadData_t *threadData, modelica_metatype _cr)
 
DLLExport modelica_metatype omc_Absyn_expCref (threadData_t *threadData, modelica_metatype _exp)
 
DLLExport modelica_string omc_Absyn_expString (threadData_t *threadData, modelica_metatype _exp)
 
DLLExport modelica_string omc_Absyn_printImportString (threadData_t *threadData, modelica_metatype _imp)
 
DLLExport modelica_boolean omc_Absyn_isClassdef (threadData_t *threadData, modelica_metatype _inElement)
 
modelica_metatype boxptr_Absyn_isClassdef (threadData_t *threadData, modelica_metatype _inElement)
 
DLLExport modelica_string omc_Absyn_elementSpecName (threadData_t *threadData, modelica_metatype _inElementSpec)
 
DLLExport modelica_boolean omc_Absyn_isClassNamed (threadData_t *threadData, modelica_string _inName, modelica_metatype _inClass)
 
modelica_metatype boxptr_Absyn_isClassNamed (threadData_t *threadData, modelica_metatype _inName, modelica_metatype _inClass)
 
DLLExport modelica_metatype omc_Absyn_className (threadData_t *threadData, modelica_metatype _cl)
 
DLLExport modelica_metatype omc_Absyn_makeQualifiedPathFromStrings (threadData_t *threadData, modelica_string _s1, modelica_string _s2)
 
DLLExport modelica_metatype omc_Absyn_makeIdentPathFromString (threadData_t *threadData, modelica_string _s)
 
DLLExport modelica_metatype omc_Absyn_traverseEquationBidir (threadData_t *threadData, modelica_metatype _inEquation, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_traverseMatchCase (threadData_t *threadData, modelica_metatype _inMatchCase, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpBidirIterator (threadData_t *threadData, modelica_metatype _inIterator, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpBidirNamedArg (threadData_t *threadData, modelica_metatype _inArg, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inExtra, modelica_metatype *out_outExtra)
 
DLLExport modelica_metatype omc_Absyn_traverseExpBidirFunctionArgs (threadData_t *threadData, modelica_metatype _inArgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpBidirElseIf (threadData_t *threadData, modelica_metatype _inElseIf, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpBidirSubs (threadData_t *threadData, modelica_metatype _inSubscript, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpBidirCref (threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpOptBidir (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpBidir (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpListBidir (threadData_t *threadData, modelica_metatype _inExpl, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpList (threadData_t *threadData, modelica_metatype _inExpList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpTopDown (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_traverseExp (threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
 
DLLExport modelica_metatype omc_Absyn_traverseExpAlgItemTupleList (threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
 
DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItemList (threadData_t *threadData, modelica_metatype _inAlgorithmItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
 
DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItem (threadData_t *threadData, modelica_metatype _inAlgorithmItem, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
 
DLLExport modelica_metatype omc_Absyn_traverseAlgorithm (threadData_t *threadData, modelica_metatype _inAlgorithm, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
 
DLLExport modelica_metatype omc_Absyn_traverseExpEqItemTupleList (threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
 
DLLExport modelica_metatype omc_Absyn_traverseEquationItemList (threadData_t *threadData, modelica_metatype _inEquationItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
 
DLLExport modelica_metatype omc_Absyn_traverseEquation (threadData_t *threadData, modelica_metatype _inEquation, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
 

Function Documentation

◆ boxptr_Absyn_classNameCompare()

modelica_metatype boxptr_Absyn_classNameCompare ( threadData_t threadData,
modelica_metatype  _c1,
modelica_metatype  _c2 
)

Definition at line 16704 of file Absyn.c.

16705 {
16706  modelica_integer _o;
16707  modelica_metatype out_o;
16708  _o = omc_Absyn_classNameCompare(threadData, _c1, _c2);
16709  out_o = mmc_mk_icon(_o);
16710  return out_o;
16711 }
m_integer modelica_integer
DLLExport modelica_integer omc_Absyn_classNameCompare(threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
Definition: Absyn.c:16693
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_classNameGreater()

modelica_metatype boxptr_Absyn_classNameGreater ( threadData_t threadData,
modelica_metatype  _c1,
modelica_metatype  _c2 
)

Definition at line 16683 of file Absyn.c.

16684 {
16685  modelica_boolean _b;
16686  modelica_metatype out_b;
16687  _b = omc_Absyn_classNameGreater(threadData, _c1, _c2);
16688  out_b = mmc_mk_icon(_b);
16689  return out_b;
16690 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_classNameGreater(threadData_t *threadData, modelica_metatype _c1, modelica_metatype _c2)
Definition: Absyn.c:16672
Here is the call graph for this function:

◆ boxptr_Absyn_crefEqual()

modelica_metatype boxptr_Absyn_crefEqual ( threadData_t threadData,
modelica_metatype  _iCr1,
modelica_metatype  _iCr2 
)

Definition at line 10104 of file Absyn.c.

10105 {
10106  modelica_boolean _outBoolean;
10107  modelica_metatype out_outBoolean;
10108  _outBoolean = omc_Absyn_crefEqual(threadData, _iCr1, _iCr2);
10109  out_outBoolean = mmc_mk_icon(_outBoolean);
10110  return out_outBoolean;
10111 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_crefEqual(threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
Definition: Absyn.c:9953
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_crefEqualNoSubs()

modelica_metatype boxptr_Absyn_crefEqualNoSubs ( threadData_t threadData,
modelica_metatype  _cr1,
modelica_metatype  _cr2 
)

Definition at line 9826 of file Absyn.c.

9827 {
9828  modelica_boolean _outBoolean;
9829  modelica_metatype out_outBoolean;
9830  _outBoolean = omc_Absyn_crefEqualNoSubs(threadData, _cr1, _cr2);
9831  out_outBoolean = mmc_mk_icon(_outBoolean);
9832  return out_outBoolean;
9833 }
DLLExport modelica_boolean omc_Absyn_crefEqualNoSubs(threadData_t *threadData, modelica_metatype _cr1, modelica_metatype _cr2)
Definition: Absyn.c:9702
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_crefFirstEqual()

modelica_metatype boxptr_Absyn_crefFirstEqual ( threadData_t threadData,
modelica_metatype  _iCr1,
modelica_metatype  _iCr2 
)

Definition at line 9943 of file Absyn.c.

9944 {
9945  modelica_boolean _outBoolean;
9946  modelica_metatype out_outBoolean;
9947  _outBoolean = omc_Absyn_crefFirstEqual(threadData, _iCr1, _iCr2);
9948  out_outBoolean = mmc_mk_icon(_outBoolean);
9949  return out_outBoolean;
9950 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_crefFirstEqual(threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
Definition: Absyn.c:9932
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_crefHasSubscripts()

modelica_metatype boxptr_Absyn_crefHasSubscripts ( threadData_t threadData,
modelica_metatype  _cref 
)

Definition at line 11353 of file Absyn.c.

11354 {
11355  modelica_boolean _hasSubscripts;
11356  modelica_metatype out_hasSubscripts;
11357  _hasSubscripts = omc_Absyn_crefHasSubscripts(threadData, _cref);
11358  out_hasSubscripts = mmc_mk_icon(_hasSubscripts);
11359  return out_hasSubscripts;
11360 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_crefHasSubscripts(threadData_t *threadData, modelica_metatype _cref)
Definition: Absyn.c:11256
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_crefIsFullyQualified()

modelica_metatype boxptr_Absyn_crefIsFullyQualified ( threadData_t threadData,
modelica_metatype  _inCref 
)

Definition at line 10649 of file Absyn.c.

10650 {
10651  modelica_boolean _outIsFullyQualified;
10652  modelica_metatype out_outIsFullyQualified;
10653  _outIsFullyQualified = omc_Absyn_crefIsFullyQualified(threadData, _inCref);
10654  out_outIsFullyQualified = mmc_mk_icon(_outIsFullyQualified);
10655  return out_outIsFullyQualified;
10656 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_crefIsFullyQualified(threadData_t *threadData, modelica_metatype _inCref)
Definition: Absyn.c:10601
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_crefIsIdent()

modelica_metatype boxptr_Absyn_crefIsIdent ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11633 of file Absyn.c.

11634 {
11635  modelica_boolean _outIsIdent;
11636  modelica_metatype out_outIsIdent;
11637  _outIsIdent = omc_Absyn_crefIsIdent(threadData, _inComponentRef);
11638  out_outIsIdent = mmc_mk_icon(_outIsIdent);
11639  return out_outIsIdent;
11640 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_crefIsIdent(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:11585
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_crefIsQual()

modelica_metatype boxptr_Absyn_crefIsQual ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11575 of file Absyn.c.

11576 {
11577  modelica_boolean _outIsQual;
11578  modelica_metatype out_outIsQual;
11579  _outIsQual = omc_Absyn_crefIsQual(threadData, _inComponentRef);
11580  out_outIsQual = mmc_mk_icon(_outIsQual);
11581  return out_outIsQual;
11582 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_crefIsQual(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:11521
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_crefPrefixOf()

modelica_metatype boxptr_Absyn_crefPrefixOf ( threadData_t threadData,
modelica_metatype  _prefixCr,
modelica_metatype  _cr 
)

Definition at line 14538 of file Absyn.c.

14539 {
14540  modelica_boolean _out;
14541  modelica_metatype out_out;
14542  _out = omc_Absyn_crefPrefixOf(threadData, _prefixCr, _cr);
14543  out_out = mmc_mk_icon(_out);
14544  return out_out;
14545 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_crefPrefixOf(threadData_t *threadData, modelica_metatype _prefixCr, modelica_metatype _cr)
Definition: Absyn.c:14470
Here is the call graph for this function:

◆ boxptr_Absyn_directionEqual()

modelica_metatype boxptr_Absyn_directionEqual ( threadData_t threadData,
modelica_metatype  _inDirection1,
modelica_metatype  _inDirection2 
)

Definition at line 6203 of file Absyn.c.

6204 {
6205  modelica_boolean _outEqual;
6206  modelica_metatype out_outEqual;
6207  _outEqual = omc_Absyn_directionEqual(threadData, _inDirection1, _inDirection2);
6208  out_outEqual = mmc_mk_icon(_outEqual);
6209  return out_outEqual;
6210 }
DLLExport modelica_boolean omc_Absyn_directionEqual(threadData_t *threadData, modelica_metatype _inDirection1, modelica_metatype _inDirection2)
Definition: Absyn.c:6127
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_eachEqual()

modelica_metatype boxptr_Absyn_eachEqual ( threadData_t threadData,
modelica_metatype  _each1,
modelica_metatype  _each2 
)

Definition at line 9480 of file Absyn.c.

9481 {
9482  modelica_boolean _equal;
9483  modelica_metatype out_equal;
9484  _equal = omc_Absyn_eachEqual(threadData, _each1, _each2);
9485  out_equal = mmc_mk_icon(_equal);
9486  return out_equal;
9487 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_eachEqual(threadData_t *threadData, modelica_metatype _each1, modelica_metatype _each2)
Definition: Absyn.c:9422
Here is the call graph for this function:

◆ boxptr_Absyn_elementArgEqualName()

modelica_metatype boxptr_Absyn_elementArgEqualName ( threadData_t threadData,
modelica_metatype  _inArg1,
modelica_metatype  _inArg2 
)

Definition at line 2192 of file Absyn.c.

2193 {
2194  modelica_boolean _outEqual;
2195  modelica_metatype out_outEqual;
2196  _outEqual = omc_Absyn_elementArgEqualName(threadData, _inArg1, _inArg2);
2197  out_outEqual = mmc_mk_icon(_outEqual);
2198  return out_outEqual;
2199 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_elementArgEqualName(threadData_t *threadData, modelica_metatype _inArg1, modelica_metatype _inArg2)
Definition: Absyn.c:2135
Here is the call graph for this function:

◆ boxptr_Absyn_expContainsInitial()

modelica_metatype boxptr_Absyn_expContainsInitial ( threadData_t threadData,
modelica_metatype  _inExp 
)

Definition at line 5269 of file Absyn.c.

5270 {
5271  modelica_boolean _hasInitial;
5272  modelica_metatype out_hasInitial;
5273  _hasInitial = omc_Absyn_expContainsInitial(threadData, _inExp);
5274  out_hasInitial = mmc_mk_icon(_hasInitial);
5275  return out_hasInitial;
5276 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_expContainsInitial(threadData_t *threadData, modelica_metatype _inExp)
Definition: Absyn.c:5204
Here is the call graph for this function:

◆ boxptr_Absyn_expEqual()

modelica_metatype boxptr_Absyn_expEqual ( threadData_t threadData,
modelica_metatype  _exp1,
modelica_metatype  _exp2 
)

Definition at line 9577 of file Absyn.c.

9578 {
9579  modelica_boolean _equal;
9580  modelica_metatype out_equal;
9581  _equal = omc_Absyn_expEqual(threadData, _exp1, _exp2);
9582  out_equal = mmc_mk_icon(_equal);
9583  return out_equal;
9584 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_expEqual(threadData_t *threadData, modelica_metatype _exp1, modelica_metatype _exp2)
Definition: Absyn.c:9490
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_filterAnnotationItem()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_filterAnnotationItem ( threadData_t threadData,
modelica_metatype  _elt 
)

Definition at line 5605 of file Absyn.c.

5606 {
5607  modelica_boolean _outB;
5608  modelica_metatype out_outB;
5609  _outB = omc_Absyn_filterAnnotationItem(threadData, _elt);
5610  out_outB = mmc_mk_icon(_outB);
5611  return out_outB;
5612 }
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_filterAnnotationItem(threadData_t *threadData, modelica_metatype _elt)
Definition: Absyn.c:5557
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_functionArgsEqual()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_functionArgsEqual ( threadData_t threadData,
modelica_metatype  _args1,
modelica_metatype  _args2 
)

Definition at line 9412 of file Absyn.c.

9413 {
9414  modelica_boolean _equal;
9415  modelica_metatype out_equal;
9416  _equal = omc_Absyn_functionArgsEqual(threadData, _args1, _args2);
9417  out_equal = mmc_mk_icon(_equal);
9418  return out_equal;
9419 }
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_functionArgsEqual(threadData_t *threadData, modelica_metatype _args1, modelica_metatype _args2)
Definition: Absyn.c:9355
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_getCrefFromExp()

modelica_metatype boxptr_Absyn_getCrefFromExp ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_metatype  _includeSubs,
modelica_metatype  _includeFunctions 
)

Definition at line 13734 of file Absyn.c.

13735 {
13736  modelica_integer tmp1;
13737  modelica_integer tmp2;
13738  modelica_metatype _outComponentRefLst = NULL;
13739  tmp1 = mmc_unbox_integer(_includeSubs);
13740  tmp2 = mmc_unbox_integer(_includeFunctions);
13741  _outComponentRefLst = omc_Absyn_getCrefFromExp(threadData, _inExp, tmp1, tmp2);
13742  /* skip box _outComponentRefLst; list<Absyn.ComponentRef> */
13743  return _outComponentRefLst;
13744 }
m_integer modelica_integer
DLLExport modelica_metatype omc_Absyn_getCrefFromExp(threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13198
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_getCrefFromFarg()

modelica_metatype boxptr_Absyn_getCrefFromFarg ( threadData_t threadData,
modelica_metatype  _inFunctionArgs,
modelica_metatype  _includeSubs,
modelica_metatype  _includeFunctions 
)

Definition at line 13185 of file Absyn.c.

13186 {
13187  modelica_integer tmp1;
13188  modelica_integer tmp2;
13189  modelica_metatype _outComponentRefLst = NULL;
13190  tmp1 = mmc_unbox_integer(_includeSubs);
13191  tmp2 = mmc_unbox_integer(_includeFunctions);
13192  _outComponentRefLst = omc_Absyn_getCrefFromFarg(threadData, _inFunctionArgs, tmp1, tmp2);
13193  /* skip box _outComponentRefLst; list<Absyn.ComponentRef> */
13194  return _outComponentRefLst;
13195 }
DLLExport modelica_metatype omc_Absyn_getCrefFromFarg(threadData_t *threadData, modelica_metatype _inFunctionArgs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13087
m_integer modelica_integer
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_getCrefFromNarg()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_getCrefFromNarg ( threadData_t threadData,
modelica_metatype  _inNamedArg,
modelica_metatype  _includeSubs,
modelica_metatype  _includeFunctions 
)

Definition at line 12931 of file Absyn.c.

12932 {
12933  modelica_integer tmp1;
12934  modelica_integer tmp2;
12935  modelica_metatype _outComponentRefLst = NULL;
12936  tmp1 = mmc_unbox_integer(_includeSubs);
12937  tmp2 = mmc_unbox_integer(_includeFunctions);
12938  _outComponentRefLst = omc_Absyn_getCrefFromNarg(threadData, _inNamedArg, tmp1, tmp2);
12939  /* skip box _outComponentRefLst; list<Absyn.ComponentRef> */
12940  return _outComponentRefLst;
12941 }
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getCrefFromNarg(threadData_t *threadData, modelica_metatype _inNamedArg, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:12890
m_integer modelica_integer
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_getCrefsFromSubs()

modelica_metatype boxptr_Absyn_getCrefsFromSubs ( threadData_t threadData,
modelica_metatype  _isubs,
modelica_metatype  _includeSubs,
modelica_metatype  _includeFunctions 
)

Definition at line 13830 of file Absyn.c.

13831 {
13832  modelica_integer tmp1;
13833  modelica_integer tmp2;
13834  modelica_metatype _crefs = NULL;
13835  tmp1 = mmc_unbox_integer(_includeSubs);
13836  tmp2 = mmc_unbox_integer(_includeFunctions);
13837  _crefs = omc_Absyn_getCrefsFromSubs(threadData, _isubs, tmp1, tmp2);
13838  /* skip box _crefs; list<Absyn.ComponentRef> */
13839  return _crefs;
13840 }
m_integer modelica_integer
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_getCrefsFromSubs(threadData_t *threadData, modelica_metatype _isubs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13747
Here is the call graph for this function:

◆ boxptr_Absyn_getExpsFromArrayDim()

modelica_metatype boxptr_Absyn_getExpsFromArrayDim ( threadData_t threadData,
modelica_metatype  _inAd,
modelica_metatype out_outExps 
)

Definition at line 6615 of file Absyn.c.

6616 {
6617  modelica_boolean _hasUnknownDimensions;
6618  modelica_metatype out_hasUnknownDimensions;
6619  _hasUnknownDimensions = omc_Absyn_getExpsFromArrayDim(threadData, _inAd, out_outExps);
6620  out_hasUnknownDimensions = mmc_mk_icon(_hasUnknownDimensions);
6621  /* skip box _outExps; list<Absyn.Exp> */
6622  return out_hasUnknownDimensions;
6623 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim(threadData_t *threadData, modelica_metatype _inAd, modelica_metatype *out_outExps)
Definition: Absyn.c:6599
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_getExpsFromArrayDim__tail()

modelica_metatype boxptr_Absyn_getExpsFromArrayDim__tail ( threadData_t threadData,
modelica_metatype  _inAd,
modelica_metatype  _inAccumulator,
modelica_metatype out_outExps 
)

Definition at line 6513 of file Absyn.c.

6514 {
6515  modelica_boolean _hasUnknownDimensions;
6516  modelica_metatype out_hasUnknownDimensions;
6517  _hasUnknownDimensions = omc_Absyn_getExpsFromArrayDim__tail(threadData, _inAd, _inAccumulator, out_outExps);
6518  out_hasUnknownDimensions = mmc_mk_icon(_hasUnknownDimensions);
6519  /* skip box _outExps; list<Absyn.Exp> */
6520  return out_hasUnknownDimensions;
6521 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim__tail(threadData_t *threadData, modelica_metatype _inAd, modelica_metatype _inAccumulator, modelica_metatype *out_outExps)
Definition: Absyn.c:6412
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_getExpsFromArrayDimOpt()

modelica_metatype boxptr_Absyn_getExpsFromArrayDimOpt ( threadData_t threadData,
modelica_metatype  _inAdO,
modelica_metatype out_outExps 
)

Definition at line 6588 of file Absyn.c.

6589 {
6590  modelica_boolean _hasUnknownDimensions;
6591  modelica_metatype out_hasUnknownDimensions;
6592  _hasUnknownDimensions = omc_Absyn_getExpsFromArrayDimOpt(threadData, _inAdO, out_outExps);
6593  out_hasUnknownDimensions = mmc_mk_icon(_hasUnknownDimensions);
6594  /* skip box _outExps; list<Absyn.Exp> */
6595  return out_hasUnknownDimensions;
6596 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDimOpt(threadData_t *threadData, modelica_metatype _inAdO, modelica_metatype *out_outExps)
Definition: Absyn.c:6524
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_getSubsFromCref()

modelica_metatype boxptr_Absyn_getSubsFromCref ( threadData_t threadData,
modelica_metatype  _cr,
modelica_metatype  _includeSubs,
modelica_metatype  _includeFunctions 
)

Definition at line 11243 of file Absyn.c.

11244 {
11245  modelica_integer tmp1;
11246  modelica_integer tmp2;
11247  modelica_metatype _subscripts = NULL;
11248  tmp1 = mmc_unbox_integer(_includeSubs);
11249  tmp2 = mmc_unbox_integer(_includeFunctions);
11250  _subscripts = omc_Absyn_getSubsFromCref(threadData, _cr, tmp1, tmp2);
11251  /* skip box _subscripts; list<Absyn.Subscript> */
11252  return _subscripts;
11253 }
m_integer modelica_integer
DLLExport modelica_metatype omc_Absyn_getSubsFromCref(threadData_t *threadData, modelica_metatype _cr, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:11171
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_importEqual()

modelica_metatype boxptr_Absyn_importEqual ( threadData_t threadData,
modelica_metatype  _im1,
modelica_metatype  _im2 
)

Definition at line 8273 of file Absyn.c.

8274 {
8275  modelica_boolean _outBoolean;
8276  modelica_metatype out_outBoolean;
8277  _outBoolean = omc_Absyn_importEqual(threadData, _im1, _im2);
8278  out_outBoolean = mmc_mk_icon(_outBoolean);
8279  return out_outBoolean;
8280 }
DLLExport modelica_boolean omc_Absyn_importEqual(threadData_t *threadData, modelica_metatype _im1, modelica_metatype _im2)
Definition: Absyn.c:8142
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_innerOuterEqual()

modelica_metatype boxptr_Absyn_innerOuterEqual ( threadData_t threadData,
modelica_metatype  _io1,
modelica_metatype  _io2 
)

Definition at line 8463 of file Absyn.c.

8464 {
8465  modelica_boolean _res;
8466  modelica_metatype out_res;
8467  _res = omc_Absyn_innerOuterEqual(threadData, _io1, _io2);
8468  out_res = mmc_mk_icon(_res);
8469  return out_res;
8470 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_innerOuterEqual(threadData_t *threadData, modelica_metatype _io1, modelica_metatype _io2)
Definition: Absyn.c:8387
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isAlgorithmItem()

modelica_metatype boxptr_Absyn_isAlgorithmItem ( threadData_t threadData,
modelica_metatype  _inAlg 
)

Definition at line 868 of file Absyn.c.

869 {
870  modelica_boolean _outIsClass;
871  modelica_metatype out_outIsClass;
872  _outIsClass = omc_Absyn_isAlgorithmItem(threadData, _inAlg);
873  out_outIsClass = mmc_mk_icon(_outIsClass);
874  return out_outIsClass;
875 }
DLLExport modelica_boolean omc_Absyn_isAlgorithmItem(threadData_t *threadData, modelica_metatype _inAlg)
Definition: Absyn.c:820
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isClassdef()

modelica_metatype boxptr_Absyn_isClassdef ( threadData_t threadData,
modelica_metatype  _inElement 
)

Definition at line 18054 of file Absyn.c.

18055 {
18056  modelica_boolean _b;
18057  modelica_metatype out_b;
18058  _b = omc_Absyn_isClassdef(threadData, _inElement);
18059  out_b = mmc_mk_icon(_b);
18060  return out_b;
18061 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isClassdef(threadData_t *threadData, modelica_metatype _inElement)
Definition: Absyn.c:18003
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isClassNamed()

modelica_metatype boxptr_Absyn_isClassNamed ( threadData_t threadData,
modelica_metatype  _inName,
modelica_metatype  _inClass 
)

Definition at line 18174 of file Absyn.c.

18175 {
18176  modelica_boolean _outIsNamed;
18177  modelica_metatype out_outIsNamed;
18178  _outIsNamed = omc_Absyn_isClassNamed(threadData, _inName, _inClass);
18179  out_outIsNamed = mmc_mk_icon(_outIsNamed);
18180  return out_outIsNamed;
18181 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isClassNamed(threadData_t *threadData, modelica_string _inName, modelica_metatype _inClass)
Definition: Absyn.c:18127
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isCref()

modelica_metatype boxptr_Absyn_isCref ( threadData_t threadData,
modelica_metatype  _exp 
)

Definition at line 6855 of file Absyn.c.

6856 {
6857  modelica_boolean _b;
6858  modelica_metatype out_b;
6859  _b = omc_Absyn_isCref(threadData, _exp);
6860  out_b = mmc_mk_icon(_b);
6861  return out_b;
6862 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isCref(threadData_t *threadData, modelica_metatype _exp)
Definition: Absyn.c:6807
Here is the call graph for this function:

◆ boxptr_Absyn_isDerCref()

modelica_metatype boxptr_Absyn_isDerCref ( threadData_t threadData,
modelica_metatype  _exp 
)

Definition at line 6739 of file Absyn.c.

6740 {
6741  modelica_boolean _b;
6742  modelica_metatype out_b;
6743  _b = omc_Absyn_isDerCref(threadData, _exp);
6744  out_b = mmc_mk_icon(_b);
6745  return out_b;
6746 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isDerCref(threadData_t *threadData, modelica_metatype _exp)
Definition: Absyn.c:6675
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isElementItem()

modelica_metatype boxptr_Absyn_isElementItem ( threadData_t threadData,
modelica_metatype  _inElement 
)

Definition at line 926 of file Absyn.c.

927 {
928  modelica_boolean _outIsClass;
929  modelica_metatype out_outIsClass;
930  _outIsClass = omc_Absyn_isElementItem(threadData, _inElement);
931  out_outIsClass = mmc_mk_icon(_outIsClass);
932  return out_outIsClass;
933 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isElementItem(threadData_t *threadData, modelica_metatype _inElement)
Definition: Absyn.c:878
Here is the call graph for this function:

◆ boxptr_Absyn_isElementItemClass()

modelica_metatype boxptr_Absyn_isElementItemClass ( threadData_t threadData,
modelica_metatype  _inElement 
)

Definition at line 989 of file Absyn.c.

990 {
991  modelica_boolean _outIsClass;
992  modelica_metatype out_outIsClass;
993  _outIsClass = omc_Absyn_isElementItemClass(threadData, _inElement);
994  out_outIsClass = mmc_mk_icon(_outIsClass);
995  return out_outIsClass;
996 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isElementItemClass(threadData_t *threadData, modelica_metatype _inElement)
Definition: Absyn.c:936
Here is the call graph for this function:

◆ boxptr_Absyn_isElementItemClassNamed()

modelica_metatype boxptr_Absyn_isElementItemClassNamed ( threadData_t threadData,
modelica_metatype  _inName,
modelica_metatype  _inElement 
)

Definition at line 810 of file Absyn.c.

811 {
812  modelica_boolean _outIsNamed;
813  modelica_metatype out_outIsNamed;
814  _outIsNamed = omc_Absyn_isElementItemClassNamed(threadData, _inName, _inElement);
815  out_outIsNamed = mmc_mk_icon(_outIsNamed);
816  return out_outIsNamed;
817 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isElementItemClassNamed(threadData_t *threadData, modelica_string _inName, modelica_metatype _inElement)
Definition: Absyn.c:753
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isEmptyClassPart()

modelica_metatype boxptr_Absyn_isEmptyClassPart ( threadData_t threadData,
modelica_metatype  _inClassPart 
)

Definition at line 743 of file Absyn.c.

744 {
745  modelica_boolean _outIsEmpty;
746  modelica_metatype out_outIsEmpty;
747  _outIsEmpty = omc_Absyn_isEmptyClassPart(threadData, _inClassPart);
748  out_outIsEmpty = mmc_mk_icon(_outIsEmpty);
749  return out_outIsEmpty;
750 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isEmptyClassPart(threadData_t *threadData, modelica_metatype _inClassPart)
Definition: Absyn.c:633
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isEmptyMod()

modelica_metatype boxptr_Absyn_isEmptyMod ( threadData_t threadData,
modelica_metatype  _inMod 
)

Definition at line 2392 of file Absyn.c.

2393 {
2394  modelica_boolean _outIsEmpty;
2395  modelica_metatype out_outIsEmpty;
2396  _outIsEmpty = omc_Absyn_isEmptyMod(threadData, _inMod);
2397  out_outIsEmpty = mmc_mk_icon(_outIsEmpty);
2398  return out_outIsEmpty;
2399 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isEmptyMod(threadData_t *threadData, modelica_metatype _inMod)
Definition: Absyn.c:2325
Here is the call graph for this function:

◆ boxptr_Absyn_isEmptySubMod()

modelica_metatype boxptr_Absyn_isEmptySubMod ( threadData_t threadData,
modelica_metatype  _inSubMod 
)

Definition at line 2315 of file Absyn.c.

2316 {
2317  modelica_boolean _outIsEmpty;
2318  modelica_metatype out_outIsEmpty;
2319  _outIsEmpty = omc_Absyn_isEmptySubMod(threadData, _inSubMod);
2320  out_outIsEmpty = mmc_mk_icon(_outIsEmpty);
2321  return out_outIsEmpty;
2322 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isEmptySubMod(threadData_t *threadData, modelica_metatype _inSubMod)
Definition: Absyn.c:2258
Here is the call graph for this function:

◆ boxptr_Absyn_isExternalPart()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_isExternalPart ( threadData_t threadData,
modelica_metatype  _inClassPart 
)

Definition at line 5518 of file Absyn.c.

5519 {
5520  modelica_boolean _outFound;
5521  modelica_metatype out_outFound;
5522  _outFound = omc_Absyn_isExternalPart(threadData, _inClassPart);
5523  out_outFound = mmc_mk_icon(_outFound);
5524  return out_outFound;
5525 }
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_isExternalPart(threadData_t *threadData, modelica_metatype _inClassPart)
Definition: Absyn.c:5470
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isFieldEqual()

modelica_metatype boxptr_Absyn_isFieldEqual ( threadData_t threadData,
modelica_metatype  _isField1,
modelica_metatype  _isField2 
)

Definition at line 6117 of file Absyn.c.

6118 {
6119  modelica_boolean _outEqual;
6120  modelica_metatype out_outEqual;
6121  _outEqual = omc_Absyn_isFieldEqual(threadData, _isField1, _isField2);
6122  out_outEqual = mmc_mk_icon(_outEqual);
6123  return out_outEqual;
6124 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isFieldEqual(threadData_t *threadData, modelica_metatype _isField1, modelica_metatype _isField2)
Definition: Absyn.c:6059
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isFunctionRestriction()

modelica_metatype boxptr_Absyn_isFunctionRestriction ( threadData_t threadData,
modelica_metatype  _inRestriction 
)

Definition at line 9635 of file Absyn.c.

9636 {
9637  modelica_boolean _outIsFunction;
9638  modelica_metatype out_outIsFunction;
9639  _outIsFunction = omc_Absyn_isFunctionRestriction(threadData, _inRestriction);
9640  out_outIsFunction = mmc_mk_icon(_outIsFunction);
9641  return out_outIsFunction;
9642 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isFunctionRestriction(threadData_t *threadData, modelica_metatype _inRestriction)
Definition: Absyn.c:9587
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isInitial()

modelica_metatype boxptr_Absyn_isInitial ( threadData_t threadData,
modelica_metatype  _inExp 
)

Definition at line 5104 of file Absyn.c.

5105 {
5106  modelica_boolean _hasReinit;
5107  modelica_metatype out_hasReinit;
5108  _hasReinit = omc_Absyn_isInitial(threadData, _inExp);
5109  out_hasReinit = mmc_mk_icon(_hasReinit);
5110  return out_hasReinit;
5111 }
DLLExport modelica_boolean omc_Absyn_isInitial(threadData_t *threadData, modelica_metatype _inExp)
Definition: Absyn.c:5036
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isInitialTraverseHelper()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_isInitialTraverseHelper ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_metatype  _inBool,
modelica_metatype out_outBool 
)

Definition at line 5191 of file Absyn.c.

5192 {
5193  modelica_integer tmp1;
5194  modelica_boolean _outBool;
5195  modelica_metatype _outExp = NULL;
5196  tmp1 = mmc_unbox_integer(_inBool);
5197  _outExp = omc_Absyn_isInitialTraverseHelper(threadData, _inExp, tmp1, &_outBool);
5198  /* skip box _outExp; Absyn.Exp */
5199  if (out_outBool) { *out_outBool = mmc_mk_icon(_outBool); }
5200  return _outExp;
5201 }
m_integer modelica_integer
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_isInitialTraverseHelper(threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _inBool, modelica_boolean *out_outBool)
Definition: Absyn.c:5113
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isInner()

modelica_metatype boxptr_Absyn_isInner ( threadData_t threadData,
modelica_metatype  _io 
)

Definition at line 8755 of file Absyn.c.

8756 {
8757  modelica_boolean _isItAnInner;
8758  modelica_metatype out_isItAnInner;
8759  _isItAnInner = omc_Absyn_isInner(threadData, _io);
8760  out_isItAnInner = mmc_mk_icon(_isItAnInner);
8761  return out_isItAnInner;
8762 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isInner(threadData_t *threadData, modelica_metatype _io)
Definition: Absyn.c:8701
Here is the call graph for this function:

◆ boxptr_Absyn_isInnerOuter()

modelica_metatype boxptr_Absyn_isInnerOuter ( threadData_t threadData,
modelica_metatype  _inIO 
)

Definition at line 8577 of file Absyn.c.

8578 {
8579  modelica_boolean _outIsInnerOuter;
8580  modelica_metatype out_outIsInnerOuter;
8581  _outIsInnerOuter = omc_Absyn_isInnerOuter(threadData, _inIO);
8582  out_outIsInnerOuter = mmc_mk_icon(_outIsInnerOuter);
8583  return out_outIsInnerOuter;
8584 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isInnerOuter(threadData_t *threadData, modelica_metatype _inIO)
Definition: Absyn.c:8530
Here is the call graph for this function:

◆ boxptr_Absyn_isInput()

modelica_metatype boxptr_Absyn_isInput ( threadData_t threadData,
modelica_metatype  _inDirection 
)

Definition at line 6331 of file Absyn.c.

6332 {
6333  modelica_boolean _outIsInput;
6334  modelica_metatype out_outIsInput;
6335  _outIsInput = omc_Absyn_isInput(threadData, _inDirection);
6336  out_outIsInput = mmc_mk_icon(_outIsInput);
6337  return out_outIsInput;
6338 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isInput(threadData_t *threadData, modelica_metatype _inDirection)
Definition: Absyn.c:6277
Here is the call graph for this function:

◆ boxptr_Absyn_isInputOrOutput()

modelica_metatype boxptr_Absyn_isInputOrOutput ( threadData_t threadData,
modelica_metatype  _direction 
)

Definition at line 6402 of file Absyn.c.

6403 {
6404  modelica_boolean _isIorO;
6405  modelica_metatype out_isIorO;
6406  _isIorO = omc_Absyn_isInputOrOutput(threadData, _direction);
6407  out_isIorO = mmc_mk_icon(_isIorO);
6408  return out_isIorO;
6409 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isInputOrOutput(threadData_t *threadData, modelica_metatype _direction)
Definition: Absyn.c:6341
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isInvariantExpNoTraverse()

modelica_metatype boxptr_Absyn_isInvariantExpNoTraverse ( threadData_t threadData,
modelica_metatype $in_e,
modelica_metatype $in_b,
modelica_metatype out_b 
)

Definition at line 620 of file Absyn.c.

621 {
622  modelica_integer tmp1;
623  modelica_boolean _b;
624  modelica_metatype _e = NULL;
625  tmp1 = mmc_unbox_integer(_$in_b);
626  _e = omc_Absyn_isInvariantExpNoTraverse(threadData, _$in_e, tmp1, &_b);
627  /* skip box _e; Absyn.Exp */
628  if (out_b) { *out_b = mmc_mk_icon(_b); }
629  return _e;
630 }
m_integer modelica_integer
signed char modelica_boolean
DLLExport modelica_metatype omc_Absyn_isInvariantExpNoTraverse(threadData_t *threadData, modelica_metatype _ $in_e, modelica_boolean _ $in_b, modelica_boolean *out_b)
Definition: Absyn.c:410
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isModificationOfPath()

modelica_metatype boxptr_Absyn_isModificationOfPath ( threadData_t threadData,
modelica_metatype  _mod,
modelica_metatype  _path 
)

Definition at line 4638 of file Absyn.c.

4639 {
4640  modelica_boolean _yes;
4641  modelica_metatype out_yes;
4642  _yes = omc_Absyn_isModificationOfPath(threadData, _mod, _path);
4643  out_yes = mmc_mk_icon(_yes);
4644  return out_yes;
4645 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isModificationOfPath(threadData_t *threadData, modelica_metatype _mod, modelica_metatype _path)
Definition: Absyn.c:4579
Here is the call graph for this function:

◆ boxptr_Absyn_isNotInnerOuter()

modelica_metatype boxptr_Absyn_isNotInnerOuter ( threadData_t threadData,
modelica_metatype  _inIO 
)

Definition at line 8520 of file Absyn.c.

8521 {
8522  modelica_boolean _outIsNotInnerOuter;
8523  modelica_metatype out_outIsNotInnerOuter;
8524  _outIsNotInnerOuter = omc_Absyn_isNotInnerOuter(threadData, _inIO);
8525  out_outIsNotInnerOuter = mmc_mk_icon(_outIsNotInnerOuter);
8526  return out_outIsNotInnerOuter;
8527 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isNotInnerOuter(threadData_t *threadData, modelica_metatype _inIO)
Definition: Absyn.c:8473
Here is the call graph for this function:

◆ boxptr_Absyn_isOnlyInner()

modelica_metatype boxptr_Absyn_isOnlyInner ( threadData_t threadData,
modelica_metatype  _inIO 
)

Definition at line 8691 of file Absyn.c.

8692 {
8693  modelica_boolean _outOnlyInner;
8694  modelica_metatype out_outOnlyInner;
8695  _outOnlyInner = omc_Absyn_isOnlyInner(threadData, _inIO);
8696  out_outOnlyInner = mmc_mk_icon(_outOnlyInner);
8697  return out_outOnlyInner;
8698 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isOnlyInner(threadData_t *threadData, modelica_metatype _inIO)
Definition: Absyn.c:8644
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isOnlyOuter()

modelica_metatype boxptr_Absyn_isOnlyOuter ( threadData_t threadData,
modelica_metatype  _inIO 
)

Definition at line 8634 of file Absyn.c.

8635 {
8636  modelica_boolean _outOnlyOuter;
8637  modelica_metatype out_outOnlyOuter;
8638  _outOnlyOuter = omc_Absyn_isOnlyOuter(threadData, _inIO);
8639  out_outOnlyOuter = mmc_mk_icon(_outOnlyOuter);
8640  return out_outOnlyOuter;
8641 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isOnlyOuter(threadData_t *threadData, modelica_metatype _inIO)
Definition: Absyn.c:8587
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isOuter()

modelica_metatype boxptr_Absyn_isOuter ( threadData_t threadData,
modelica_metatype  _io 
)

Definition at line 8819 of file Absyn.c.

8820 {
8821  modelica_boolean _isItAnOuter;
8822  modelica_metatype out_isItAnOuter;
8823  _isItAnOuter = omc_Absyn_isOuter(threadData, _io);
8824  out_isItAnOuter = mmc_mk_icon(_isItAnOuter);
8825  return out_isItAnOuter;
8826 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isOuter(threadData_t *threadData, modelica_metatype _io)
Definition: Absyn.c:8765
Here is the call graph for this function:

◆ boxptr_Absyn_isOutput()

modelica_metatype boxptr_Absyn_isOutput ( threadData_t threadData,
modelica_metatype  _inDirection 
)

Definition at line 6267 of file Absyn.c.

6268 {
6269  modelica_boolean _outIsOutput;
6270  modelica_metatype out_outIsOutput;
6271  _outIsOutput = omc_Absyn_isOutput(threadData, _inDirection);
6272  out_outIsOutput = mmc_mk_icon(_outIsOutput);
6273  return out_outIsOutput;
6274 }
DLLExport modelica_boolean omc_Absyn_isOutput(threadData_t *threadData, modelica_metatype _inDirection)
Definition: Absyn.c:6213
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isPackageRestriction()

modelica_metatype boxptr_Absyn_isPackageRestriction ( threadData_t threadData,
modelica_metatype  _inRestriction 
)

Definition at line 9692 of file Absyn.c.

9693 {
9694  modelica_boolean _outIsPackage;
9695  modelica_metatype out_outIsPackage;
9696  _outIsPackage = omc_Absyn_isPackageRestriction(threadData, _inRestriction);
9697  out_outIsPackage = mmc_mk_icon(_outIsPackage);
9698  return out_outIsPackage;
9699 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isPackageRestriction(threadData_t *threadData, modelica_metatype _inRestriction)
Definition: Absyn.c:9645
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isParts()

modelica_metatype boxptr_Absyn_isParts ( threadData_t threadData,
modelica_metatype  _cl 
)

Definition at line 5461 of file Absyn.c.

5462 {
5463  modelica_boolean _b;
5464  modelica_metatype out_b;
5465  _b = omc_Absyn_isParts(threadData, _cl);
5466  out_b = mmc_mk_icon(_b);
5467  return out_b;
5468 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_isParts(threadData_t *threadData, modelica_metatype _cl)
Definition: Absyn.c:5413
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_isTuple()

modelica_metatype boxptr_Absyn_isTuple ( threadData_t threadData,
modelica_metatype  _inExp 
)

Definition at line 6797 of file Absyn.c.

6798 {
6799  modelica_boolean _outIsTuple;
6800  modelica_metatype out_outIsTuple;
6801  _outIsTuple = omc_Absyn_isTuple(threadData, _inExp);
6802  out_outIsTuple = mmc_mk_icon(_outIsTuple);
6803  return out_outIsTuple;
6804 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isTuple(threadData_t *threadData, modelica_metatype _inExp)
Definition: Absyn.c:6749
Here is the call graph for this function:

◆ boxptr_Absyn_iteratorIndexedCrefsEqual()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_iteratorIndexedCrefsEqual ( threadData_t threadData,
modelica_metatype  _inCref1,
modelica_metatype  _inCref2 
)

Definition at line 9239 of file Absyn.c.

9240 {
9241  modelica_boolean _outEqual;
9242  modelica_metatype out_outEqual;
9243  _outEqual = omc_Absyn_iteratorIndexedCrefsEqual(threadData, _inCref1, _inCref2);
9244  out_outEqual = mmc_mk_icon(_outEqual);
9245  return out_outEqual;
9246 }
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_iteratorIndexedCrefsEqual(threadData_t *threadData, modelica_metatype _inCref1, modelica_metatype _inCref2)
Definition: Absyn.c:9189
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_onlyLiteralsInAnnotationMod()

modelica_metatype boxptr_Absyn_onlyLiteralsInAnnotationMod ( threadData_t threadData,
modelica_metatype  _inMod 
)

Definition at line 8050 of file Absyn.c.

8051 {
8052  modelica_boolean _onlyLiterals;
8053  modelica_metatype out_onlyLiterals;
8054  _onlyLiterals = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _inMod);
8055  out_onlyLiterals = mmc_mk_icon(_onlyLiterals);
8056  return out_onlyLiterals;
8057 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_onlyLiteralsInAnnotationMod(threadData_t *threadData, modelica_metatype _inMod)
Definition: Absyn.c:7927
Here is the call graph for this function:

◆ boxptr_Absyn_onlyLiteralsInEqMod()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_onlyLiteralsInEqMod ( threadData_t threadData,
modelica_metatype  _eqMod 
)

Definition at line 7917 of file Absyn.c.

7918 {
7919  modelica_boolean _onlyLiterals;
7920  modelica_metatype out_onlyLiterals;
7921  _onlyLiterals = omc_Absyn_onlyLiteralsInEqMod(threadData, _eqMod);
7922  out_onlyLiterals = mmc_mk_icon(_onlyLiterals);
7923  return out_onlyLiterals;
7924 }
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_onlyLiteralsInEqMod(threadData_t *threadData, modelica_metatype _eqMod)
Definition: Absyn.c:7834
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_opEqual()

modelica_metatype boxptr_Absyn_opEqual ( threadData_t threadData,
modelica_metatype  _op1,
modelica_metatype  _op2 
)

Definition at line 3452 of file Absyn.c.

3453 {
3454  modelica_boolean _isEqual;
3455  modelica_metatype out_isEqual;
3456  _isEqual = omc_Absyn_opEqual(threadData, _op1, _op2);
3457  out_isEqual = mmc_mk_icon(_isEqual);
3458  return out_isEqual;
3459 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_opEqual(threadData_t *threadData, modelica_metatype _op1, modelica_metatype _op2)
Definition: Absyn.c:3441
Here is the call graph for this function:

◆ boxptr_Absyn_opIsElementWise()

modelica_metatype boxptr_Absyn_opIsElementWise ( threadData_t threadData,
modelica_metatype  _op 
)

Definition at line 3431 of file Absyn.c.

3432 {
3433  modelica_boolean _isElementWise;
3434  modelica_metatype out_isElementWise;
3435  _isElementWise = omc_Absyn_opIsElementWise(threadData, _op);
3436  out_isElementWise = mmc_mk_icon(_isElementWise);
3437  return out_isElementWise;
3438 }
DLLExport modelica_boolean omc_Absyn_opIsElementWise(threadData_t *threadData, modelica_metatype _op)
Definition: Absyn.c:3337
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_optArrayDimEqual()

modelica_metatype boxptr_Absyn_optArrayDimEqual ( threadData_t threadData,
modelica_metatype  _oad1,
modelica_metatype  _oad2 
)

Definition at line 17458 of file Absyn.c.

17459 {
17460  modelica_boolean _b;
17461  modelica_metatype out_b;
17462  _b = omc_Absyn_optArrayDimEqual(threadData, _oad1, _oad2);
17463  out_b = mmc_mk_icon(_b);
17464  return out_b;
17465 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_optArrayDimEqual(threadData_t *threadData, modelica_metatype _oad1, modelica_metatype _oad2)
Definition: Absyn.c:17375
Here is the call graph for this function:

◆ boxptr_Absyn_optMsg()

modelica_metatype boxptr_Absyn_optMsg ( threadData_t threadData,
modelica_metatype  _inShowMessage,
modelica_metatype  _inInfo 
)

Definition at line 2124 of file Absyn.c.

2125 {
2126  modelica_integer tmp1;
2127  modelica_metatype _outMsg = NULL;
2128  tmp1 = mmc_unbox_integer(_inShowMessage);
2129  _outMsg = omc_Absyn_optMsg(threadData, tmp1, _inInfo);
2130  /* skip box _outMsg; Absyn.Msg */
2131  return _outMsg;
2132 }
m_integer modelica_integer
DLLExport modelica_metatype omc_Absyn_optMsg(threadData_t *threadData, modelica_boolean _inShowMessage, modelica_metatype _inInfo)
Definition: Absyn.c:2091
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathCompare()

modelica_metatype boxptr_Absyn_pathCompare ( threadData_t threadData,
modelica_metatype  _ip1,
modelica_metatype  _ip2 
)

Definition at line 16662 of file Absyn.c.

16663 {
16664  modelica_integer _o;
16665  modelica_metatype out_o;
16666  _o = omc_Absyn_pathCompare(threadData, _ip1, _ip2);
16667  out_o = mmc_mk_icon(_o);
16668  return out_o;
16669 }
m_integer modelica_integer
DLLExport modelica_integer omc_Absyn_pathCompare(threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
Definition: Absyn.c:16507
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathCompareNoQual()

modelica_metatype boxptr_Absyn_pathCompareNoQual ( threadData_t threadData,
modelica_metatype  _ip1,
modelica_metatype  _ip2 
)

Definition at line 16497 of file Absyn.c.

16498 {
16499  modelica_integer _o;
16500  modelica_metatype out_o;
16501  _o = omc_Absyn_pathCompareNoQual(threadData, _ip1, _ip2);
16502  out_o = mmc_mk_icon(_o);
16503  return out_o;
16504 }
m_integer modelica_integer
void * modelica_metatype
DLLExport modelica_integer omc_Absyn_pathCompareNoQual(threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
Definition: Absyn.c:16369
Here is the call graph for this function:

◆ boxptr_Absyn_pathContains()

modelica_metatype boxptr_Absyn_pathContains ( threadData_t threadData,
modelica_metatype  _fullPath,
modelica_metatype  _pathId 
)

Definition at line 14129 of file Absyn.c.

14130 {
14131  modelica_boolean _b;
14132  modelica_metatype out_b;
14133  _b = omc_Absyn_pathContains(threadData, _fullPath, _pathId);
14134  out_b = mmc_mk_icon(_b);
14135  return out_b;
14136 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathContains(threadData_t *threadData, modelica_metatype _fullPath, modelica_metatype _pathId)
Definition: Absyn.c:14041
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathContainsString()

modelica_metatype boxptr_Absyn_pathContainsString ( threadData_t threadData,
modelica_metatype  _p1,
modelica_metatype  _str 
)

Definition at line 14031 of file Absyn.c.

14032 {
14033  modelica_boolean _b;
14034  modelica_metatype out_b;
14035  _b = omc_Absyn_pathContainsString(threadData, _p1, _str);
14036  out_b = mmc_mk_icon(_b);
14037  return out_b;
14038 }
DLLExport modelica_boolean omc_Absyn_pathContainsString(threadData_t *threadData, modelica_metatype _p1, modelica_string _str)
Definition: Absyn.c:13942
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathEqual()

modelica_metatype boxptr_Absyn_pathEqual ( threadData_t threadData,
modelica_metatype  _inPath1,
modelica_metatype  _inPath2 
)

Definition at line 17759 of file Absyn.c.

17760 {
17761  modelica_boolean _outBoolean;
17762  modelica_metatype out_outBoolean;
17763  _outBoolean = omc_Absyn_pathEqual(threadData, _inPath1, _inPath2);
17764  out_outBoolean = mmc_mk_icon(_outBoolean);
17765  return out_outBoolean;
17766 }
DLLExport modelica_boolean omc_Absyn_pathEqual(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:17616
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathGe()

modelica_metatype boxptr_Absyn_pathGe ( threadData_t threadData,
modelica_metatype  _path1,
modelica_metatype  _path2 
)

Definition at line 6028 of file Absyn.c.

6029 {
6030  modelica_boolean _ge;
6031  modelica_metatype out_ge;
6032  _ge = omc_Absyn_pathGe(threadData, _path1, _path2);
6033  out_ge = mmc_mk_icon(_ge);
6034  return out_ge;
6035 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathGe(threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
Definition: Absyn.c:6017
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathHashMod()

modelica_metatype boxptr_Absyn_pathHashMod ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _mod 
)

Definition at line 16357 of file Absyn.c.

16358 {
16359  modelica_integer tmp1;
16360  modelica_integer _hash;
16361  modelica_metatype out_hash;
16362  tmp1 = mmc_unbox_integer(_mod);
16363  _hash = omc_Absyn_pathHashMod(threadData, _path, tmp1);
16364  out_hash = mmc_mk_icon(_hash);
16365  return out_hash;
16366 }
m_integer modelica_integer
DLLExport modelica_integer omc_Absyn_pathHashMod(threadData_t *threadData, modelica_metatype _path, modelica_integer _mod)
Definition: Absyn.c:16346
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathHashModWork()

modelica_metatype boxptr_Absyn_pathHashModWork ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _acc 
)

Definition at line 16334 of file Absyn.c.

16335 {
16336  modelica_integer tmp1;
16337  modelica_integer _hash;
16338  modelica_metatype out_hash;
16339  tmp1 = mmc_unbox_integer(_acc);
16340  _hash = omc_Absyn_pathHashModWork(threadData, _path, tmp1);
16341  out_hash = mmc_mk_icon(_hash);
16342  return out_hash;
16343 }
m_integer modelica_integer
DLLExport modelica_integer omc_Absyn_pathHashModWork(threadData_t *threadData, modelica_metatype _path, modelica_integer _acc)
Definition: Absyn.c:16238
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathIsFullyQualified()

modelica_metatype boxptr_Absyn_pathIsFullyQualified ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 7524 of file Absyn.c.

7525 {
7526  modelica_boolean _outIsQualified;
7527  modelica_metatype out_outIsQualified;
7528  _outIsQualified = omc_Absyn_pathIsFullyQualified(threadData, _inPath);
7529  out_outIsQualified = mmc_mk_icon(_outIsQualified);
7530  return out_outIsQualified;
7531 }
DLLExport modelica_boolean omc_Absyn_pathIsFullyQualified(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:7476
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathIsIdent()

modelica_metatype boxptr_Absyn_pathIsIdent ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 7466 of file Absyn.c.

7467 {
7468  modelica_boolean _outIsIdent;
7469  modelica_metatype out_outIsIdent;
7470  _outIsIdent = omc_Absyn_pathIsIdent(threadData, _inPath);
7471  out_outIsIdent = mmc_mk_icon(_outIsIdent);
7472  return out_outIsIdent;
7473 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_pathIsIdent(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:7418
Here is the call graph for this function:

◆ boxptr_Absyn_pathIsQual()

modelica_metatype boxptr_Absyn_pathIsQual ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 7408 of file Absyn.c.

7409 {
7410  modelica_boolean _outIsQual;
7411  modelica_metatype out_outIsQual;
7412  _outIsQual = omc_Absyn_pathIsQual(threadData, _inPath);
7413  out_outIsQual = mmc_mk_icon(_outIsQual);
7414  return out_outIsQual;
7415 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathIsQual(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:7360
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathLt()

modelica_metatype boxptr_Absyn_pathLt ( threadData_t threadData,
modelica_metatype  _path1,
modelica_metatype  _path2 
)

Definition at line 6049 of file Absyn.c.

6050 {
6051  modelica_boolean _lt;
6052  modelica_metatype out_lt;
6053  _lt = omc_Absyn_pathLt(threadData, _path1, _path2);
6054  out_lt = mmc_mk_icon(_lt);
6055  return out_lt;
6056 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathLt(threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
Definition: Absyn.c:6038
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathPartCount()

modelica_metatype boxptr_Absyn_pathPartCount ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _partsAccum 
)

Definition at line 398 of file Absyn.c.

399 {
400  modelica_integer tmp1;
401  modelica_integer _parts;
402  modelica_metatype out_parts;
403  tmp1 = mmc_unbox_integer(_partsAccum);
404  _parts = omc_Absyn_pathPartCount(threadData, _path, tmp1);
405  out_parts = mmc_mk_icon(_parts);
406  return out_parts;
407 }
m_integer modelica_integer
DLLExport modelica_integer omc_Absyn_pathPartCount(threadData_t *threadData, modelica_metatype _path, modelica_integer _partsAccum)
Definition: Absyn.c:329
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathPrefixOf()

modelica_metatype boxptr_Absyn_pathPrefixOf ( threadData_t threadData,
modelica_metatype  _prefixPath,
modelica_metatype  _path 
)

Definition at line 14688 of file Absyn.c.

14689 {
14690  modelica_boolean _isPrefix;
14691  modelica_metatype out_isPrefix;
14692  _isPrefix = omc_Absyn_pathPrefixOf(threadData, _prefixPath, _path);
14693  out_isPrefix = mmc_mk_icon(_isPrefix);
14694  return out_isPrefix;
14695 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathPrefixOf(threadData_t *threadData, modelica_metatype _prefixPath, modelica_metatype _path)
Definition: Absyn.c:14548
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_pathString()

modelica_metatype boxptr_Absyn_pathString ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _delimiter,
modelica_metatype  _usefq,
modelica_metatype  _reverse 
)

Definition at line 17181 of file Absyn.c.

17182 {
17183  modelica_integer tmp1;
17184  modelica_integer tmp2;
17185  modelica_string _s = NULL;
17186  tmp1 = mmc_unbox_integer(_usefq);
17187  tmp2 = mmc_unbox_integer(_reverse);
17188  _s = omc_Absyn_pathString(threadData, _path, _delimiter, tmp1, tmp2);
17189  /* skip box _s; String */
17190  return _s;
17191 }
modelica_metatype modelica_string
m_integer modelica_integer
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
Here is the call graph for this function:

◆ boxptr_Absyn_pathStringNoQual()

modelica_metatype boxptr_Absyn_pathStringNoQual ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _delimiter,
modelica_metatype  _usefq,
modelica_metatype  _reverse 
)

Definition at line 16885 of file Absyn.c.

16886 {
16887  modelica_integer tmp1;
16888  modelica_integer tmp2;
16889  modelica_string _s = NULL;
16890  tmp1 = mmc_unbox_integer(_usefq);
16891  tmp2 = mmc_unbox_integer(_reverse);
16892  _s = omc_Absyn_pathStringNoQual(threadData, _path, _delimiter, tmp1, tmp2);
16893  /* skip box _s; String */
16894  return _s;
16895 }
modelica_metatype modelica_string
m_integer modelica_integer
DLLExport modelica_string omc_Absyn_pathStringNoQual(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:16725
Here is the call graph for this function:

◆ boxptr_Absyn_pathStringWork()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_pathStringWork ( threadData_t threadData,
modelica_metatype  _inPath,
modelica_metatype  _len,
modelica_metatype  _delimiter,
modelica_metatype  _dlen,
modelica_metatype  _reverse 
)

Definition at line 17006 of file Absyn.c.

17007 {
17008  modelica_integer tmp1;
17009  modelica_integer tmp2;
17010  modelica_integer tmp3;
17011  modelica_string _s = NULL;
17012  tmp1 = mmc_unbox_integer(_len);
17013  tmp2 = mmc_unbox_integer(_dlen);
17014  tmp3 = mmc_unbox_integer(_reverse);
17015  _s = omc_Absyn_pathStringWork(threadData, _inPath, tmp1, _delimiter, tmp2, tmp3);
17016  /* skip box _s; String */
17017  return _s;
17018 }
PROTECTED_FUNCTION_STATIC modelica_string omc_Absyn_pathStringWork(threadData_t *threadData, modelica_metatype _inPath, modelica_integer _len, modelica_string _delimiter, modelica_integer _dlen, modelica_boolean _reverse)
Definition: Absyn.c:16897
modelica_metatype modelica_string
m_integer modelica_integer
Here is the call graph for this function:

◆ boxptr_Absyn_pathSuffixOf()

modelica_metatype boxptr_Absyn_pathSuffixOf ( threadData_t threadData,
modelica_metatype  _suffix_path,
modelica_metatype  _path 
)

Definition at line 15116 of file Absyn.c.

15117 {
15118  modelica_boolean _res;
15119  modelica_metatype out_res;
15120  _res = omc_Absyn_pathSuffixOf(threadData, _suffix_path, _path);
15121  out_res = mmc_mk_icon(_res);
15122  return out_res;
15123 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_pathSuffixOf(threadData_t *threadData, modelica_metatype _suffix_path, modelica_metatype _path)
Definition: Absyn.c:15029
Here is the call graph for this function:

◆ boxptr_Absyn_pathSuffixOfr()

modelica_metatype boxptr_Absyn_pathSuffixOfr ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _suffix_path 
)

Definition at line 15019 of file Absyn.c.

15020 {
15021  modelica_boolean _res;
15022  modelica_metatype out_res;
15023  _res = omc_Absyn_pathSuffixOfr(threadData, _path, _suffix_path);
15024  out_res = mmc_mk_icon(_res);
15025  return out_res;
15026 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathSuffixOfr(threadData_t *threadData, modelica_metatype _path, modelica_metatype _suffix_path)
Definition: Absyn.c:15008
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_subscriptEqual()

modelica_metatype boxptr_Absyn_subscriptEqual ( threadData_t threadData,
modelica_metatype  _inSubscript1,
modelica_metatype  _inSubscript2 
)

Definition at line 9922 of file Absyn.c.

9923 {
9924  modelica_boolean _outIsEqual;
9925  modelica_metatype out_outIsEqual;
9926  _outIsEqual = omc_Absyn_subscriptEqual(threadData, _inSubscript1, _inSubscript2);
9927  out_outIsEqual = mmc_mk_icon(_outIsEqual);
9928  return out_outIsEqual;
9929 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_subscriptEqual(threadData_t *threadData, modelica_metatype _inSubscript1, modelica_metatype _inSubscript2)
Definition: Absyn.c:9857
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_subscriptsEqual()

modelica_metatype boxptr_Absyn_subscriptsEqual ( threadData_t threadData,
modelica_metatype  _inSubList1,
modelica_metatype  _inSubList2 
)

Definition at line 9847 of file Absyn.c.

9848 {
9849  modelica_boolean _outIsEqual;
9850  modelica_metatype out_outIsEqual;
9851  _outIsEqual = omc_Absyn_subscriptsEqual(threadData, _inSubList1, _inSubList2);
9852  out_outIsEqual = mmc_mk_icon(_outIsEqual);
9853  return out_outIsEqual;
9854 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_subscriptsEqual(threadData_t *threadData, modelica_metatype _inSubList1, modelica_metatype _inSubList2)
Definition: Absyn.c:9836
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_traverseClassDef()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseClassDef ( threadData_t threadData,
modelica_metatype  _inClassDef,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_metatype out_outContinue 
)

Definition at line 2483 of file Absyn.c.

2484 {
2485  modelica_boolean _outContinue;
2486  modelica_metatype _outClassDef = NULL;
2487  _outClassDef = omc_Absyn_traverseClassDef(threadData, _inClassDef, _inFunc, _inArg, out_outArg, &_outContinue);
2488  /* skip box _outClassDef; Absyn.ClassDef */
2489  /* skip box _outArg; polymorphic<ArgT> */
2490  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
2491  return _outClassDef;
2492 }
signed char modelica_boolean
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassDef(threadData_t *threadData, modelica_metatype _inClassDef, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2401
Here is the call graph for this function:

◆ boxptr_Absyn_traverseClassPartComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseClassPartComponents ( threadData_t threadData,
modelica_metatype  _inClassPart,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_metatype out_outContinue 
)

Definition at line 2909 of file Absyn.c.

2910 {
2911  modelica_boolean _outContinue;
2912  modelica_metatype _outClassPart = NULL;
2913  _outClassPart = omc_Absyn_traverseClassPartComponents(threadData, _inClassPart, _inFunc, _inArg, out_outArg, &_outContinue);
2914  /* skip box _outClassPart; Absyn.ClassPart */
2915  /* skip box _outArg; polymorphic<ArgT> */
2916  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
2917  return _outClassPart;
2918 }
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassPartComponents(threadData_t *threadData, modelica_metatype _inClassPart, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2823
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_traverseElementComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementComponents ( threadData_t threadData,
modelica_metatype  _inElement,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_metatype out_outContinue 
)

Definition at line 2694 of file Absyn.c.

2695 {
2696  modelica_boolean _outContinue;
2697  modelica_metatype _outElement = NULL;
2698  _outElement = omc_Absyn_traverseElementComponents(threadData, _inElement, _inFunc, _inArg, out_outArg, &_outContinue);
2699  /* skip box _outElement; Absyn.Element */
2700  /* skip box _outArg; polymorphic<ArgT> */
2701  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
2702  return _outElement;
2703 }
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementComponents(threadData_t *threadData, modelica_metatype _inElement, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2605
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_traverseElementItemComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementItemComponents ( threadData_t threadData,
modelica_metatype  _inItem,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_metatype out_outContinue 
)

Definition at line 2803 of file Absyn.c.

2804 {
2805  modelica_boolean _outContinue;
2806  modelica_metatype _outItem = NULL;
2807  _outItem = omc_Absyn_traverseElementItemComponents(threadData, _inItem, _inFunc, _inArg, out_outArg, &_outContinue);
2808  /* skip box _outItem; Absyn.ElementItem */
2809  /* skip box _outArg; polymorphic<ArgT> */
2810  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
2811  return _outItem;
2812 }
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementItemComponents(threadData_t *threadData, modelica_metatype _inItem, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2705
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_traverseElementSpecComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseElementSpecComponents ( threadData_t threadData,
modelica_metatype  _inSpec,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_metatype out_outContinue 
)

Definition at line 2594 of file Absyn.c.

2595 {
2596  modelica_boolean _outContinue;
2597  modelica_metatype _outSpec = NULL;
2598  _outSpec = omc_Absyn_traverseElementSpecComponents(threadData, _inSpec, _inFunc, _inArg, out_outArg, &_outContinue);
2599  /* skip box _outSpec; Absyn.ElementSpec */
2600  /* skip box _outArg; polymorphic<ArgT> */
2601  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
2602  return _outSpec;
2603 }
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementSpecComponents(threadData_t *threadData, modelica_metatype _inSpec, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2494
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ boxptr_Absyn_traverseListGeneric()

PROTECTED_FUNCTION_STATIC modelica_metatype boxptr_Absyn_traverseListGeneric ( threadData_t threadData,
modelica_metatype  _inList,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_metatype out_outContinue 
)

Definition at line 3019 of file Absyn.c.

3020 {
3021  modelica_boolean _outContinue;
3022  modelica_metatype _outList = NULL;
3023  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
3024  _outList = omc_Absyn_traverseListGeneric(threadData, _inList, _inFunc, _inArg, out_outArg, &_outContinue);
3025  /* skip box _outList; list<polymorphic<T>> */
3026  /* skip box _outArg; polymorphic<ArgT> */
3027  if (out_outContinue) { *out_outContinue = mmc_mk_icon(_outContinue); }
3028  return _outList;
3029 }
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseListGeneric(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2920
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ boxptr_Absyn_typeSpecEqual()

modelica_metatype boxptr_Absyn_typeSpecEqual ( threadData_t threadData,
modelica_metatype  _a,
modelica_metatype  _b 
)

Definition at line 17606 of file Absyn.c.

17607 {
17608  modelica_boolean _ob;
17609  modelica_metatype out_ob;
17610  _ob = omc_Absyn_typeSpecEqual(threadData, _a, _b);
17611  out_ob = mmc_mk_icon(_ob);
17612  return out_ob;
17613 }
signed char modelica_boolean
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_typeSpecEqual(threadData_t *threadData, modelica_metatype _a, modelica_metatype _b)
Definition: Absyn.c:17468
Here is the call graph for this function:

◆ boxptr_Absyn_withinEqual()

modelica_metatype boxptr_Absyn_withinEqual ( threadData_t threadData,
modelica_metatype  _within1,
modelica_metatype  _within2 
)

Definition at line 7350 of file Absyn.c.

7351 {
7352  modelica_boolean _b;
7353  modelica_metatype out_b;
7354  _b = omc_Absyn_withinEqual(threadData, _within1, _within2);
7355  out_b = mmc_mk_icon(_b);
7356  return out_b;
7357 }
DLLExport modelica_boolean omc_Absyn_withinEqual(threadData_t *threadData, modelica_metatype _within1, modelica_metatype _within2)
Definition: Absyn.c:7285
signed char modelica_boolean
void * modelica_metatype
Here is the call graph for this function:

◆ omc_Absyn_addSubscriptsLast()

DLLExport modelica_metatype omc_Absyn_addSubscriptsLast ( threadData_t threadData,
modelica_metatype  _icr,
modelica_metatype  _i 
)

Definition at line 14777 of file Absyn.c.

14778 {
14779  modelica_metatype _ocr = NULL;
14780  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
14781  MMC_SO();
14782  _tailrecursive: OMC_LABEL_UNUSED
14783 #line 14783 OMC_FILE
14784  { /* match expression */
14785  modelica_metatype tmp3_1;
14786  tmp3_1 = _icr;
14787  {
14788  modelica_metatype _subs = NULL;
14789  modelica_string _id = NULL;
14790  modelica_metatype _cr = NULL;
14791  int tmp3;
14792  {
14793  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
14794  case 5: {
14795  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
14796  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14797  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
14798  _id = tmpMeta[1];
14799  _subs = tmpMeta[2];
14800  /* Pattern matching succeeded */
14801 #line 3216 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14802  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, listAppend(_subs, _i));
14803 #line 3216 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14804  tmpMeta[0] = tmpMeta[1];
14805 #line 14805 OMC_FILE
14806  goto tmp2_done;
14807  }
14808  case 4: {
14809  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
14810  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14811  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
14812  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
14813  _id = tmpMeta[1];
14814  _subs = tmpMeta[2];
14815  _cr = tmpMeta[3];
14816  /* Pattern matching succeeded */
14817 #line 3220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14818  _cr = omc_Absyn_addSubscriptsLast(threadData, _cr, _i);
14819 #line 14819 OMC_FILE
14820 #line 3221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14821  tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _subs, _cr);
14822 #line 3221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14823  tmpMeta[0] = tmpMeta[1];
14824 #line 14824 OMC_FILE
14825  goto tmp2_done;
14826  }
14827  case 3: {
14828  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
14829  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14830  _cr = tmpMeta[1];
14831  /* Pattern matching succeeded */
14832 #line 3225 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14833  _cr = omc_Absyn_addSubscriptsLast(threadData, _cr, _i);
14834 #line 14834 OMC_FILE
14835 #line 3226 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14836  tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cr);
14837 #line 14837 OMC_FILE
14838  goto tmp2_done;
14839  }
14840  }
14841  goto tmp2_end;
14842  tmp2_end: ;
14843  }
14844  goto goto_1;
14845  goto_1:;
14846  MMC_THROW_INTERNAL();
14847  goto tmp2_done;
14848  tmp2_done:;
14849  }
14850  }
14851  _ocr = tmpMeta[0];
14852  _return: OMC_LABEL_UNUSED
14853  return _ocr;
14854 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
DLLExport modelica_metatype omc_Absyn_addSubscriptsLast(threadData_t *threadData, modelica_metatype _icr, modelica_metatype _i)
Definition: Absyn.c:14777
modelica_metatype modelica_string
modelica_metatype listAppend(modelica_metatype, modelica_metatype)
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_annotationToElementArgs()

DLLExport modelica_metatype omc_Absyn_annotationToElementArgs ( threadData_t threadData,
modelica_metatype  _ann 
)

Definition at line 4407 of file Absyn.c.

4408 {
4409  modelica_metatype _args = NULL;
4410  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
4411  MMC_SO();
4412  _tailrecursive: OMC_LABEL_UNUSED
4413 #line 5877 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4414  /* Pattern-matching assignment */
4415 #line 5877 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4416  tmpMeta[0] = _ann;
4417 #line 5877 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4418  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
4419 #line 5877 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4420  _args = tmpMeta[1];
4421 #line 4421 OMC_FILE
4422  _return: OMC_LABEL_UNUSED
4423  return _args;
4424 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_canonIfExp()

DLLExport modelica_metatype omc_Absyn_canonIfExp ( threadData_t threadData,
modelica_metatype  _inExp 
)

Definition at line 8060 of file Absyn.c.

8061 {
8062  modelica_metatype _outExp = NULL;
8063  modelica_metatype tmpMeta[9] __attribute__((unused)) = {0};
8064  MMC_SO();
8065  _tailrecursive: OMC_LABEL_UNUSED
8066 #line 8066 OMC_FILE
8067  { /* match expression */
8068  modelica_metatype tmp3_1;
8069  tmp3_1 = _inExp;
8070  {
8071  modelica_metatype _cond = NULL;
8072  modelica_metatype _tb = NULL;
8073  modelica_metatype _eb = NULL;
8074  modelica_metatype _ei_cond = NULL;
8075  modelica_metatype _ei_tb = NULL;
8076  modelica_metatype _e = NULL;
8077  modelica_metatype _eib = NULL;
8078  volatile mmc_switch_type tmp3;
8079  int tmp4;
8080  tmp3 = 0;
8081  for (; tmp3 < 2; tmp3++) {
8082  switch (MMC_SWITCH_CAST(tmp3)) {
8083  case 0: {
8084  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,10,4) == 0) goto tmp2_end;
8085  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
8086  if (!listEmpty(tmpMeta[1])) goto tmp2_end;
8087  /* Pattern matching succeeded */
8088 #line 4974 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8089  tmpMeta[0] = _inExp;
8090 #line 8090 OMC_FILE
8091  goto tmp2_done;
8092  }
8093  case 1: {
8094  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,10,4) == 0) goto tmp2_end;
8095  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
8096  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
8097  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
8098  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
8099  if (listEmpty(tmpMeta[4])) goto tmp2_end;
8100  tmpMeta[5] = MMC_CAR(tmpMeta[4]);
8101  tmpMeta[6] = MMC_CDR(tmpMeta[4]);
8102  tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 1));
8103  tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
8104  _cond = tmpMeta[1];
8105  _tb = tmpMeta[2];
8106  _eb = tmpMeta[3];
8107  _ei_cond = tmpMeta[7];
8108  _ei_tb = tmpMeta[8];
8109  _eib = tmpMeta[6];
8110  /* Pattern matching succeeded */
8111 #line 4977 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8112  tmpMeta[1] = mmc_mk_box5(13, &Absyn_Exp_IFEXP__desc, _ei_cond, _ei_tb, _eb, _eib);
8113 #line 4977 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8114  _e = omc_Absyn_canonIfExp(threadData, tmpMeta[1]);
8115 #line 8115 OMC_FILE
8116 #line 4978 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8117  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
8118 #line 4978 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8119  tmpMeta[2] = mmc_mk_box5(13, &Absyn_Exp_IFEXP__desc, _cond, _tb, _e, tmpMeta[1]);
8120 #line 4978 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8121  tmpMeta[0] = tmpMeta[2];
8122 #line 8122 OMC_FILE
8123  goto tmp2_done;
8124  }
8125  }
8126  goto tmp2_end;
8127  tmp2_end: ;
8128  }
8129  goto goto_1;
8130  goto_1:;
8131  MMC_THROW_INTERNAL();
8132  goto tmp2_done;
8133  tmp2_done:;
8134  }
8135  }
8136  _outExp = tmpMeta[0];
8137  _return: OMC_LABEL_UNUSED
8138  return _outExp;
8139 }
DLLExport modelica_metatype omc_Absyn_canonIfExp(threadData_t *threadData, modelica_metatype _inExp)
Definition: Absyn.c:8060
float mmc_switch_type
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_IFEXP__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_classFilename()

DLLExport modelica_string omc_Absyn_classFilename ( threadData_t threadData,
modelica_metatype  _inClass 
)

Definition at line 10281 of file Absyn.c.

10282 {
10283  modelica_string _outFilename = NULL;
10284  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
10285  MMC_SO();
10286  _tailrecursive: OMC_LABEL_UNUSED
10287 #line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10288  /* Pattern-matching assignment */
10289 #line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10290  tmpMeta[0] = _inClass;
10291 #line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10292  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 8));
10293 #line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10294  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
10295 #line 4451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10296  _outFilename = tmpMeta[2];
10297 #line 10297 OMC_FILE
10298  _return: OMC_LABEL_UNUSED
10299  return _outFilename;
10300 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_className()

DLLExport modelica_metatype omc_Absyn_className ( threadData_t threadData,
modelica_metatype  _cl 
)

Definition at line 18184 of file Absyn.c.

18185 {
18186  modelica_metatype _name = NULL;
18187  modelica_string _id = NULL;
18188  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
18189  MMC_SO();
18190  _tailrecursive: OMC_LABEL_UNUSED
18191 #line 2431 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18192  /* Pattern-matching assignment */
18193 #line 2431 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18194  tmpMeta[0] = _cl;
18195 #line 2431 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18196  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
18197 #line 2431 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18198  _id = tmpMeta[1];
18199 #line 18199 OMC_FILE
18200 
18201 #line 2432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18202  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _id);
18203 #line 2432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18204  _name = tmpMeta[0];
18205 #line 18205 OMC_FILE
18206  _return: OMC_LABEL_UNUSED
18207  return _name;
18208 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_classNameCompare()

DLLExport modelica_integer omc_Absyn_classNameCompare ( threadData_t threadData,
modelica_metatype  _c1,
modelica_metatype  _c2 
)

Definition at line 16693 of file Absyn.c.

16694 {
16695  modelica_integer _o;
16696  MMC_SO();
16697  _tailrecursive: OMC_LABEL_UNUSED
16698 #line 2745 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16699  _o = stringCompare((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_c1), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_c2), 2))));
16700 #line 16700 OMC_FILE
16701  _return: OMC_LABEL_UNUSED
16702  return _o;
16703 }
m_integer modelica_integer
Here is the caller graph for this function:

◆ omc_Absyn_classNameGreater()

DLLExport modelica_boolean omc_Absyn_classNameGreater ( threadData_t threadData,
modelica_metatype  _c1,
modelica_metatype  _c2 
)

Definition at line 16672 of file Absyn.c.

16673 {
16674  modelica_boolean _b;
16675  MMC_SO();
16676  _tailrecursive: OMC_LABEL_UNUSED
16677 #line 2752 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16678  _b = (stringCompare((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_c1), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_c2), 2)))) > ((modelica_integer) 0));
16679 #line 16679 OMC_FILE
16680  _return: OMC_LABEL_UNUSED
16681  return _b;
16682 }
m_integer modelica_integer
signed char modelica_boolean
Here is the caller graph for this function:

◆ omc_Absyn_componentName()

DLLExport modelica_string omc_Absyn_componentName ( threadData_t threadData,
modelica_metatype  _c 
)

Definition at line 5352 of file Absyn.c.

5353 {
5354  modelica_string _name = NULL;
5355  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
5356  MMC_SO();
5357  _tailrecursive: OMC_LABEL_UNUSED
5358 #line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5359  /* Pattern-matching assignment */
5360 #line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5361  tmpMeta[0] = _c;
5362 #line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5363  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
5364 #line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5365  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
5366 #line 5634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5367  _name = tmpMeta[2];
5368 #line 5368 OMC_FILE
5369  _return: OMC_LABEL_UNUSED
5370  return _name;
5371 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_crefEqual()

DLLExport modelica_boolean omc_Absyn_crefEqual ( threadData_t threadData,
modelica_metatype  _iCr1,
modelica_metatype  _iCr2 
)

Definition at line 9953 of file Absyn.c.

9954 {
9955  modelica_boolean _outBoolean;
9956  modelica_boolean tmp1 = 0;
9957  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
9958  MMC_SO();
9959  _tailrecursive: OMC_LABEL_UNUSED
9960 #line 9960 OMC_FILE
9961  { /* matchcontinue expression */
9962  volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
9963  tmp4_1 = _iCr1;
9964  tmp4_2 = _iCr2;
9965  {
9966  modelica_string _id = NULL;
9967  modelica_string _id2 = NULL;
9968  modelica_metatype _ss1 = NULL;
9969  modelica_metatype _ss2 = NULL;
9970  modelica_metatype _cr1 = NULL;
9971  modelica_metatype _cr2 = NULL;
9972  volatile mmc_switch_type tmp4;
9973  int tmp5;
9974  tmp4 = 0;
9975  MMC_TRY_INTERNAL(mmc_jumper)
9976  tmp3_top:
9977  threadData->mmc_jumper = &new_mmc_jumper;
9978  for (; tmp4 < 4; tmp4++) {
9979  switch (MMC_SWITCH_CAST(tmp4)) {
9980  case 0: {
9981  modelica_boolean tmp6;
9982  modelica_boolean tmp7;
9983  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
9984  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
9985  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
9986  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,2) == 0) goto tmp3_end;
9987  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
9988  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
9989  _id = tmpMeta[0];
9990  _ss1 = tmpMeta[1];
9991  _id2 = tmpMeta[2];
9992  _ss2 = tmpMeta[3];
9993  tmp4 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
9994 #line 4515 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9995  /* Pattern-matching assignment */
9996 #line 4515 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9997  tmp6 = (stringEqual(_id, _id2));
9998 #line 4515 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9999  if (1 != tmp6) goto goto_2;
10000 #line 10000 OMC_FILE
10001 
10002 #line 4516 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10003  /* Pattern-matching assignment */
10004 #line 4516 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10005  tmp7 = omc_Absyn_subscriptsEqual(threadData, _ss1, _ss2);
10006 #line 4516 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10007  if (1 != tmp7) goto goto_2;
10008 #line 10008 OMC_FILE
10009 #line 4517 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10010  tmp1 = 1;
10011 #line 10011 OMC_FILE
10012  goto tmp3_done;
10013  }
10014  case 1: {
10015  modelica_boolean tmp8;
10016  modelica_boolean tmp9;
10017  modelica_boolean tmp10;
10018  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
10019  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
10020  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
10021  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
10022  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,3) == 0) goto tmp3_end;
10023  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
10024  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
10025  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 4));
10026  _id = tmpMeta[0];
10027  _ss1 = tmpMeta[1];
10028  _cr1 = tmpMeta[2];
10029  _id2 = tmpMeta[3];
10030  _ss2 = tmpMeta[4];
10031  _cr2 = tmpMeta[5];
10032  tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
10033 #line 4522 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10034  /* Pattern-matching assignment */
10035 #line 4522 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10036  tmp8 = (stringEqual(_id, _id2));
10037 #line 4522 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10038  if (1 != tmp8) goto goto_2;
10039 #line 10039 OMC_FILE
10040 
10041 #line 4523 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10042  /* Pattern-matching assignment */
10043 #line 4523 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10044  tmp9 = omc_Absyn_subscriptsEqual(threadData, _ss1, _ss2);
10045 #line 4523 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10046  if (1 != tmp9) goto goto_2;
10047 #line 10047 OMC_FILE
10048 
10049 #line 4524 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10050  /* Pattern-matching assignment */
10051 #line 4524 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10052  tmp10 = omc_Absyn_crefEqual(threadData, _cr1, _cr2);
10053 #line 4524 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10054  if (1 != tmp10) goto goto_2;
10055 #line 10055 OMC_FILE
10056 #line 4525 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10057  tmp1 = 1;
10058 #line 10058 OMC_FILE
10059  goto tmp3_done;
10060  }
10061  case 2: {
10062  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
10063  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
10064  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,1) == 0) goto tmp3_end;
10065  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
10066  _cr1 = tmpMeta[0];
10067  _cr2 = tmpMeta[1];
10068  /* Pattern matching succeeded */
10069 #line 4529 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10070  tmp1 = omc_Absyn_crefEqual(threadData, _cr1, _cr2);
10071 #line 10071 OMC_FILE
10072  goto tmp3_done;
10073  }
10074  case 3: {
10075 
10076  /* Pattern matching succeeded */
10077 #line 4532 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10078  tmp1 = 0;
10079 #line 10079 OMC_FILE
10080  goto tmp3_done;
10081  }
10082  }
10083  goto tmp3_end;
10084  tmp3_end: ;
10085  }
10086  goto goto_2;
10087  tmp3_done:
10088  (void)tmp4;
10089  MMC_RESTORE_INTERNAL(mmc_jumper);
10090  goto tmp3_done2;
10091  goto_2:;
10092  MMC_CATCH_INTERNAL(mmc_jumper);
10093  if (++tmp4 < 4) {
10094  goto tmp3_top;
10095  }
10096  MMC_THROW_INTERNAL();
10097  tmp3_done2:;
10098  }
10099  }
10100  _outBoolean = tmp1;
10101  _return: OMC_LABEL_UNUSED
10102  return _outBoolean;
10103 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_Absyn_subscriptsEqual(threadData_t *threadData, modelica_metatype _inSubList1, modelica_metatype _inSubList2)
Definition: Absyn.c:9836
DLLExport modelica_boolean omc_Absyn_crefEqual(threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
Definition: Absyn.c:9953
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_crefEqualNoSubs()

DLLExport modelica_boolean omc_Absyn_crefEqualNoSubs ( threadData_t threadData,
modelica_metatype  _cr1,
modelica_metatype  _cr2 
)

Definition at line 9702 of file Absyn.c.

9703 {
9704  modelica_boolean _outBoolean;
9705  modelica_boolean tmp1 = 0;
9706  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
9707  MMC_SO();
9708  _tailrecursive: OMC_LABEL_UNUSED
9709 #line 9709 OMC_FILE
9710  { /* matchcontinue expression */
9711  volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
9712  tmp4_1 = _cr1;
9713  tmp4_2 = _cr2;
9714  {
9715  modelica_metatype _rest1 = NULL;
9716  modelica_metatype _rest2 = NULL;
9717  modelica_string _id = NULL;
9718  modelica_string _id2 = NULL;
9719  volatile mmc_switch_type tmp4;
9720  int tmp5;
9721  tmp4 = 0;
9722  MMC_TRY_INTERNAL(mmc_jumper)
9723  tmp3_top:
9724  threadData->mmc_jumper = &new_mmc_jumper;
9725  for (; tmp4 < 4; tmp4++) {
9726  switch (MMC_SWITCH_CAST(tmp4)) {
9727  case 0: {
9728  modelica_boolean tmp6;
9729  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
9730  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
9731  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,2) == 0) goto tmp3_end;
9732  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
9733 
9734  _id = tmpMeta[0];
9735  _id2 = tmpMeta[1];
9736  tmp4 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
9737 #line 4585 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9738  /* Pattern-matching assignment */
9739 #line 4585 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9740  tmp6 = (stringEqual(_id, _id2));
9741 #line 4585 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9742  if (1 != tmp6) goto goto_2;
9743 #line 9743 OMC_FILE
9744 #line 4586 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9745  tmp1 = 1;
9746 #line 9746 OMC_FILE
9747  goto tmp3_done;
9748  }
9749  case 1: {
9750  modelica_boolean tmp7;
9751  modelica_boolean tmp8;
9752  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
9753  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
9754  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
9755  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,3) == 0) goto tmp3_end;
9756  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
9757  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 4));
9758  _id = tmpMeta[0];
9759  _rest1 = tmpMeta[1];
9760  _id2 = tmpMeta[2];
9761  _rest2 = tmpMeta[3];
9762  tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
9763 #line 4590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9764  /* Pattern-matching assignment */
9765 #line 4590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9766  tmp7 = (stringEqual(_id, _id2));
9767 #line 4590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9768  if (1 != tmp7) goto goto_2;
9769 #line 9769 OMC_FILE
9770 
9771 #line 4591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9772  /* Pattern-matching assignment */
9773 #line 4591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9774  tmp8 = omc_Absyn_crefEqualNoSubs(threadData, _rest1, _rest2);
9775 #line 4591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9776  if (1 != tmp8) goto goto_2;
9777 #line 9777 OMC_FILE
9778 #line 4592 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9779  tmp1 = 1;
9780 #line 9780 OMC_FILE
9781  goto tmp3_done;
9782  }
9783  case 2: {
9784  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
9785  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
9786  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,1) == 0) goto tmp3_end;
9787  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
9788  _rest1 = tmpMeta[0];
9789  _rest2 = tmpMeta[1];
9790  /* Pattern matching succeeded */
9791 #line 4595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9792  tmp1 = omc_Absyn_crefEqualNoSubs(threadData, _rest1, _rest2);
9793 #line 9793 OMC_FILE
9794  goto tmp3_done;
9795  }
9796  case 3: {
9797 
9798  /* Pattern matching succeeded */
9799 #line 4596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9800  tmp1 = 0;
9801 #line 9801 OMC_FILE
9802  goto tmp3_done;
9803  }
9804  }
9805  goto tmp3_end;
9806  tmp3_end: ;
9807  }
9808  goto goto_2;
9809  tmp3_done:
9810  (void)tmp4;
9811  MMC_RESTORE_INTERNAL(mmc_jumper);
9812  goto tmp3_done2;
9813  goto_2:;
9814  MMC_CATCH_INTERNAL(mmc_jumper);
9815  if (++tmp4 < 4) {
9816  goto tmp3_top;
9817  }
9818  MMC_THROW_INTERNAL();
9819  tmp3_done2:;
9820  }
9821  }
9822  _outBoolean = tmp1;
9823  _return: OMC_LABEL_UNUSED
9824  return _outBoolean;
9825 }
DLLExport modelica_boolean omc_Absyn_crefEqualNoSubs(threadData_t *threadData, modelica_metatype _cr1, modelica_metatype _cr2)
Definition: Absyn.c:9702
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_crefExp()

DLLExport modelica_metatype omc_Absyn_crefExp ( threadData_t threadData,
modelica_metatype  _cr 
)

Definition at line 17878 of file Absyn.c.

17879 {
17880  modelica_metatype _exp = NULL;
17881  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
17882  MMC_SO();
17883  _tailrecursive: OMC_LABEL_UNUSED
17884 #line 2511 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17885  tmpMeta[0] = mmc_mk_box2(5, &Absyn_Exp_CREF__desc, _cr);
17886 #line 2511 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17887  _exp = tmpMeta[0];
17888 #line 17888 OMC_FILE
17889  _return: OMC_LABEL_UNUSED
17890  return _exp;
17891 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_CREF__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_crefExplode()

DLLExport modelica_metatype omc_Absyn_crefExplode ( threadData_t threadData,
modelica_metatype  _inCref,
modelica_metatype  _inAccum 
)

Definition at line 1999 of file Absyn.c.

2000 {
2001  modelica_metatype _outCrefParts = NULL;
2002  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
2003  MMC_SO();
2004  _tailrecursive: OMC_LABEL_UNUSED
2005 #line 2005 OMC_FILE
2006  { /* match expression */
2007  modelica_metatype tmp3_1;
2008  tmp3_1 = _inCref;
2009  {
2010  int tmp3;
2011  {
2012  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
2013  case 4: {
2014 
2015  /* Pattern matching succeeded */
2016 #line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2017  tmpMeta[2] = mmc_mk_cons(omc_Absyn_crefFirstCref(threadData, _inCref), _inAccum);
2018 #line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2019  /* Tail recursive call */
2020 #line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2021  tmpMeta[1] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 4)));
2022 #line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2023  _inAccum = tmpMeta[2];
2024 #line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2025  _inCref = tmpMeta[1];
2026 #line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2027  goto _tailrecursive;
2028 #line 6581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2029  /* TODO: Make sure any eventual dead code below is never generated */
2030 #line 2030 OMC_FILE
2031  goto tmp2_done;
2032  }
2033  case 3: {
2034 
2035  /* Pattern matching succeeded */
2036 #line 6582 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2037  /* Tail recursive call */
2038 #line 6582 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2039  _inCref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
2040 #line 6582 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2041  goto _tailrecursive;
2042 #line 6582 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2043  /* TODO: Make sure any eventual dead code below is never generated */
2044 #line 2044 OMC_FILE
2045  goto tmp2_done;
2046  }
2047  default:
2048  tmp2_default: OMC_LABEL_UNUSED; {
2049 
2050  /* Pattern matching succeeded */
2051 #line 6583 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2052  tmpMeta[1] = mmc_mk_cons(_inCref, _inAccum);
2053 #line 6583 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2054  tmpMeta[0] = listReverse(tmpMeta[1]);
2055 #line 2055 OMC_FILE
2056  goto tmp2_done;
2057  }
2058  }
2059  goto tmp2_end;
2060  tmp2_end: ;
2061  }
2062  goto goto_1;
2063  goto_1:;
2064  MMC_THROW_INTERNAL();
2065  goto tmp2_done;
2066  tmp2_done:;
2067  }
2068  }
2069  _outCrefParts = tmpMeta[0];
2070  _return: OMC_LABEL_UNUSED
2071  return _outCrefParts;
2072 }
void * modelica_metatype
modelica_metatype listReverse(modelica_metatype)
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_crefFirstCref(threadData_t *threadData, modelica_metatype _inCref)
Definition: Absyn.c:10719
Here is the caller graph for this function:

◆ omc_Absyn_crefFirstCref()

DLLExport modelica_metatype omc_Absyn_crefFirstCref ( threadData_t threadData,
modelica_metatype  _inCref 
)

Definition at line 10719 of file Absyn.c.

10720 {
10721  modelica_metatype _outCref = NULL;
10722  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
10723  MMC_SO();
10724  _tailrecursive: OMC_LABEL_UNUSED
10725 #line 10725 OMC_FILE
10726  { /* match expression */
10727  modelica_metatype tmp3_1;
10728  tmp3_1 = _inCref;
10729  {
10730  int tmp3;
10731  {
10732  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
10733  case 4: {
10734 
10735  /* Pattern matching succeeded */
10736 #line 4363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10737  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 3))));
10738 #line 4363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10739  tmpMeta[0] = tmpMeta[1];
10740 #line 10740 OMC_FILE
10741  goto tmp2_done;
10742  }
10743  case 3: {
10744 
10745  /* Pattern matching succeeded */
10746 #line 4364 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10747  /* Tail recursive call */
10748 #line 4364 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10749  _inCref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
10750 #line 4364 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10751  goto _tailrecursive;
10752 #line 4364 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10753  /* TODO: Make sure any eventual dead code below is never generated */
10754 #line 10754 OMC_FILE
10755  goto tmp2_done;
10756  }
10757  default:
10758  tmp2_default: OMC_LABEL_UNUSED; {
10759 
10760  /* Pattern matching succeeded */
10761 #line 4365 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10762  tmpMeta[0] = _inCref;
10763 #line 10763 OMC_FILE
10764  goto tmp2_done;
10765  }
10766  }
10767  goto tmp2_end;
10768  tmp2_end: ;
10769  }
10770  goto goto_1;
10771  goto_1:;
10772  MMC_THROW_INTERNAL();
10773  goto tmp2_done;
10774  tmp2_done:;
10775  }
10776  }
10777  _outCref = tmpMeta[0];
10778  _return: OMC_LABEL_UNUSED
10779  return _outCref;
10780 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_crefFirstEqual()

DLLExport modelica_boolean omc_Absyn_crefFirstEqual ( threadData_t threadData,
modelica_metatype  _iCr1,
modelica_metatype  _iCr2 
)

Definition at line 9932 of file Absyn.c.

9933 {
9934  modelica_boolean _outBoolean;
9935  MMC_SO();
9936  _tailrecursive: OMC_LABEL_UNUSED
9937 #line 4544 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9938  _outBoolean = (stringEqual(omc_Absyn_crefFirstIdent(threadData, _iCr1), omc_Absyn_crefFirstIdent(threadData, _iCr2)));
9939 #line 9939 OMC_FILE
9940  _return: OMC_LABEL_UNUSED
9941  return _outBoolean;
9942 }
signed char modelica_boolean
DLLExport modelica_string omc_Absyn_crefFirstIdent(threadData_t *threadData, modelica_metatype _inCref)
Definition: Absyn.c:10840
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_crefFirstIdent()

DLLExport modelica_string omc_Absyn_crefFirstIdent ( threadData_t threadData,
modelica_metatype  _inCref 
)

Definition at line 10840 of file Absyn.c.

10841 {
10842  modelica_string _outIdent = NULL;
10843  modelica_string tmp1 = 0;
10844  MMC_SO();
10845  _tailrecursive: OMC_LABEL_UNUSED
10846 #line 10846 OMC_FILE
10847  { /* match expression */
10848  modelica_metatype tmp4_1;
10849  tmp4_1 = _inCref;
10850  {
10851  int tmp4;
10852  {
10853  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
10854  case 5: {
10855 
10856  /* Pattern matching succeeded */
10857 #line 4341 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10858  tmp1 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
10859 #line 10859 OMC_FILE
10860  goto tmp3_done;
10861  }
10862  case 4: {
10863 
10864  /* Pattern matching succeeded */
10865 #line 4342 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10866  tmp1 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
10867 #line 10867 OMC_FILE
10868  goto tmp3_done;
10869  }
10870  case 3: {
10871 
10872  /* Pattern matching succeeded */
10873 #line 4343 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10874  /* Tail recursive call */
10875 #line 4343 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10876  _inCref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inCref), 2)));
10877 #line 4343 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10878  goto _tailrecursive;
10879 #line 4343 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10880  /* TODO: Make sure any eventual dead code below is never generated */
10881 #line 10881 OMC_FILE
10882  goto tmp3_done;
10883  }
10884  }
10885  goto tmp3_end;
10886  tmp3_end: ;
10887  }
10888  goto goto_2;
10889  goto_2:;
10890  MMC_THROW_INTERNAL();
10891  goto tmp3_done;
10892  tmp3_done:;
10893  }
10894  }
10895  _outIdent = tmp1;
10896  _return: OMC_LABEL_UNUSED
10897  return _outIdent;
10898 }
modelica_metatype modelica_string
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_crefFirstIdentNoSubs()

DLLExport modelica_string omc_Absyn_crefFirstIdentNoSubs ( threadData_t threadData,
modelica_metatype  _inCref 
)

Definition at line 11643 of file Absyn.c.

11644 {
11645  modelica_string _outIdent = NULL;
11646  modelica_string tmp1 = 0;
11647  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
11648  MMC_SO();
11649  _tailrecursive: OMC_LABEL_UNUSED
11650 #line 11650 OMC_FILE
11651  { /* match expression */
11652  modelica_metatype tmp4_1;
11653  tmp4_1 = _inCref;
11654  {
11655  modelica_string _id = NULL;
11656  modelica_metatype _cr = NULL;
11657  int tmp4;
11658  {
11659  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
11660  case 5: {
11661  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
11662  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
11663  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
11664  if (!listEmpty(tmpMeta[1])) goto tmp3_end;
11665  _id = tmpMeta[0];
11666  /* Pattern matching succeeded */
11667 #line 4135 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11668  tmp1 = _id;
11669 #line 11669 OMC_FILE
11670  goto tmp3_done;
11671  }
11672  case 4: {
11673  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
11674  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
11675  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
11676  if (!listEmpty(tmpMeta[1])) goto tmp3_end;
11677 
11678  _id = tmpMeta[0];
11679  /* Pattern matching succeeded */
11680 #line 4136 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11681  tmp1 = _id;
11682 #line 11682 OMC_FILE
11683  goto tmp3_done;
11684  }
11685  case 3: {
11686  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
11687  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
11688  _cr = tmpMeta[0];
11689  /* Pattern matching succeeded */
11690 #line 4137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11691  /* Tail recursive call */
11692 #line 4137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11693  _inCref = _cr;
11694 #line 4137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11695  goto _tailrecursive;
11696 #line 4137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11697  /* TODO: Make sure any eventual dead code below is never generated */
11698 #line 11698 OMC_FILE
11699  goto tmp3_done;
11700  }
11701  }
11702  goto tmp3_end;
11703  tmp3_end: ;
11704  }
11705  goto goto_2;
11706  goto_2:;
11707  MMC_THROW_INTERNAL();
11708  goto tmp3_done;
11709  tmp3_done:;
11710  }
11711  }
11712  _outIdent = tmp1;
11713  _return: OMC_LABEL_UNUSED
11714  return _outIdent;
11715 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_crefGetLastIdent()

DLLExport modelica_metatype omc_Absyn_crefGetLastIdent ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11091 of file Absyn.c.

11092 {
11093  modelica_metatype _outComponentRef = NULL;
11094  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
11095  MMC_SO();
11096  _tailrecursive: OMC_LABEL_UNUSED
11097 #line 11097 OMC_FILE
11098  { /* match expression */
11099  modelica_metatype tmp3_1;
11100  tmp3_1 = _inComponentRef;
11101  {
11102  modelica_metatype _cref = NULL;
11103  modelica_string _id = NULL;
11104  modelica_metatype _subs = NULL;
11105  int tmp3;
11106  {
11107  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
11108  case 5: {
11109  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
11110  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11111  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
11112  _id = tmpMeta[1];
11113  _subs = tmpMeta[2];
11114  /* Pattern matching succeeded */
11115 #line 4270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11116  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, _subs);
11117 #line 4270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11118  tmpMeta[0] = tmpMeta[1];
11119 #line 11119 OMC_FILE
11120  goto tmp2_done;
11121  }
11122  case 4: {
11123  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
11124  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
11125  _cref = tmpMeta[1];
11126  /* Pattern matching succeeded */
11127 #line 4273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11128  /* Tail recursive call */
11129 #line 4273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11130  _inComponentRef = _cref;
11131 #line 4273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11132  goto _tailrecursive;
11133 #line 4273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11134  /* TODO: Make sure any eventual dead code below is never generated */
11135 #line 11135 OMC_FILE
11136  goto tmp2_done;
11137  }
11138  case 3: {
11139  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
11140  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11141  _cref = tmpMeta[1];
11142  /* Pattern matching succeeded */
11143 #line 4278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11144  /* Tail recursive call */
11145 #line 4278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11146  _inComponentRef = _cref;
11147 #line 4278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11148  goto _tailrecursive;
11149 #line 4278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11150  /* TODO: Make sure any eventual dead code below is never generated */
11151 #line 11151 OMC_FILE
11152  goto tmp2_done;
11153  }
11154  }
11155  goto tmp2_end;
11156  tmp2_end: ;
11157  }
11158  goto goto_1;
11159  goto_1:;
11160  MMC_THROW_INTERNAL();
11161  goto tmp2_done;
11162  tmp2_done:;
11163  }
11164  }
11165  _outComponentRef = tmpMeta[0];
11166  _return: OMC_LABEL_UNUSED
11167  return _outComponentRef;
11168 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_crefHasSubscripts()

DLLExport modelica_boolean omc_Absyn_crefHasSubscripts ( threadData_t threadData,
modelica_metatype  _cref 
)

Definition at line 11256 of file Absyn.c.

11257 {
11258  modelica_boolean _hasSubscripts;
11259  modelica_boolean tmp1 = 0;
11260  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
11261  MMC_SO();
11262  _tailrecursive: OMC_LABEL_UNUSED
11263 #line 11263 OMC_FILE
11264  { /* match expression */
11265  modelica_metatype tmp4_1;
11266  tmp4_1 = _cref;
11267  {
11268  volatile mmc_switch_type tmp4;
11269  int tmp5;
11270  tmp4 = 0;
11271  for (; tmp4 < 6; tmp4++) {
11272  switch (MMC_SWITCH_CAST(tmp4)) {
11273  case 0: {
11274  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
11275 
11276  /* Pattern matching succeeded */
11277 #line 4220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11278  tmp1 = (!listEmpty((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 3)))));
11279 #line 11279 OMC_FILE
11280  goto tmp3_done;
11281  }
11282  case 1: {
11283  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
11284  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
11285  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
11286 
11287  /* Pattern matching succeeded */
11288 #line 4221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11289  /* Tail recursive call */
11290 #line 4221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11291  _cref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 4)));
11292 #line 4221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11293  goto _tailrecursive;
11294 #line 4221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11295  /* TODO: Make sure any eventual dead code below is never generated */
11296 #line 11296 OMC_FILE
11297  goto tmp3_done;
11298  }
11299  case 2: {
11300  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
11301 
11302  /* Pattern matching succeeded */
11303 #line 4222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11304  /* Tail recursive call */
11305 #line 4222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11306  _cref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 2)));
11307 #line 4222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11308  goto _tailrecursive;
11309 #line 4222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11310  /* TODO: Make sure any eventual dead code below is never generated */
11311 #line 11311 OMC_FILE
11312  goto tmp3_done;
11313  }
11314  case 3: {
11315  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
11316  /* Pattern matching succeeded */
11317 #line 4223 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11318  tmp1 = 0;
11319 #line 11319 OMC_FILE
11320  goto tmp3_done;
11321  }
11322  case 4: {
11323  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,0) == 0) goto tmp3_end;
11324  /* Pattern matching succeeded */
11325 #line 4224 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11326  tmp1 = 0;
11327 #line 11327 OMC_FILE
11328  goto tmp3_done;
11329  }
11330  case 5: {
11331 
11332  /* Pattern matching succeeded */
11333 #line 4225 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11334  tmp1 = 1;
11335 #line 11335 OMC_FILE
11336  goto tmp3_done;
11337  }
11338  }
11339  goto tmp3_end;
11340  tmp3_end: ;
11341  }
11342  goto goto_2;
11343  goto_2:;
11344  MMC_THROW_INTERNAL();
11345  goto tmp3_done;
11346  tmp3_done:;
11347  }
11348  }
11349  _hasSubscripts = tmp1;
11350  _return: OMC_LABEL_UNUSED
11351  return _hasSubscripts;
11352 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_crefIdent()

DLLExport modelica_string omc_Absyn_crefIdent ( threadData_t threadData,
modelica_metatype  _cr 
)

Definition at line 7599 of file Absyn.c.

7600 {
7601  modelica_string _str = NULL;
7602  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
7603  MMC_SO();
7604  _tailrecursive: OMC_LABEL_UNUSED
7605 #line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7606  /* Pattern-matching assignment */
7607 #line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7608  tmpMeta[0] = _cr;
7609 #line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7610  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],2,2) == 0) MMC_THROW_INTERNAL();
7611 #line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7612  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
7613 #line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7614  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
7615 #line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7616  if (!listEmpty(tmpMeta[2])) MMC_THROW_INTERNAL();
7617 #line 5137 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7618  _str = tmpMeta[1];
7619 #line 7619 OMC_FILE
7620  _return: OMC_LABEL_UNUSED
7621  return _str;
7622 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_crefInsertSubscriptLstLst()

DLLExport modelica_metatype omc_Absyn_crefInsertSubscriptLstLst ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_metatype  _inLst,
modelica_metatype out_outLst 
)

Definition at line 6978 of file Absyn.c.

6979 {
6980  modelica_metatype _outExp = NULL;
6981  modelica_metatype _outLst = NULL;
6982  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
6983  MMC_SO();
6984  _tailrecursive: OMC_LABEL_UNUSED
6985 #line 5262 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6986 
6987 #line 5262 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6988 
6989 #line 6989 OMC_FILE
6990  { /* matchcontinue expression */
6991  volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
6992  tmp4_1 = _inExp;
6993  tmp4_2 = _inLst;
6994  {
6995  modelica_metatype _cref = NULL;
6996  modelica_metatype _cref2 = NULL;
6997  modelica_metatype _subs = NULL;
6998  volatile mmc_switch_type tmp4;
6999  int tmp5;
7000  tmp4 = 0;
7001  MMC_TRY_INTERNAL(mmc_jumper)
7002  tmp3_top:
7003  threadData->mmc_jumper = &new_mmc_jumper;
7004  for (; tmp4 < 2; tmp4++) {
7005  switch (MMC_SWITCH_CAST(tmp4)) {
7006  case 0: {
7007  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
7008  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
7009 
7010  _cref = tmpMeta[2];
7011  _subs = tmp4_2;
7012  /* Pattern matching succeeded */
7013 #line 5269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7014  _cref2 = omc_Absyn_crefInsertSubscriptLstLst2(threadData, _cref, _subs);
7015 #line 7015 OMC_FILE
7016 #line 5270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7017  tmpMeta[2] = mmc_mk_box2(5, &Absyn_Exp_CREF__desc, _cref2);
7018 #line 5270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7019  tmpMeta[0+0] = tmpMeta[2];
7020 #line 5270 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7021  tmpMeta[0+1] = _subs;
7022 #line 7022 OMC_FILE
7023  goto tmp3_done;
7024  }
7025  case 1: {
7026 
7027  /* Pattern matching succeeded */
7028 #line 5272 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7029  tmpMeta[0+0] = _inExp;
7030 #line 5272 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7031  tmpMeta[0+1] = _inLst;
7032 #line 7032 OMC_FILE
7033  goto tmp3_done;
7034  }
7035  }
7036  goto tmp3_end;
7037  tmp3_end: ;
7038  }
7039  goto goto_2;
7040  tmp3_done:
7041  (void)tmp4;
7042  MMC_RESTORE_INTERNAL(mmc_jumper);
7043  goto tmp3_done2;
7044  goto_2:;
7045  MMC_CATCH_INTERNAL(mmc_jumper);
7046  if (++tmp4 < 2) {
7047  goto tmp3_top;
7048  }
7049  MMC_THROW_INTERNAL();
7050  tmp3_done2:;
7051  }
7052  }
7053  _outExp = tmpMeta[0+0];
7054  _outLst = tmpMeta[0+1];
7055  _return: OMC_LABEL_UNUSED
7056  if (out_outLst) { *out_outLst = _outLst; }
7057  return _outExp;
7058 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_CREF__desc
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_crefInsertSubscriptLstLst2(threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inSubs)
Definition: Absyn.c:6865
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:

◆ omc_Absyn_crefInsertSubscriptLstLst2()

DLLExport modelica_metatype omc_Absyn_crefInsertSubscriptLstLst2 ( threadData_t threadData,
modelica_metatype  _inCref,
modelica_metatype  _inSubs 
)

Definition at line 6865 of file Absyn.c.

6866 {
6867  modelica_metatype _outCref = NULL;
6868  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
6869  MMC_SO();
6870  _tailrecursive: OMC_LABEL_UNUSED
6871 #line 6871 OMC_FILE
6872  { /* matchcontinue expression */
6873  volatile modelica_metatype tmp3_1;volatile modelica_metatype tmp3_2;
6874  tmp3_1 = _inCref;
6875  tmp3_2 = _inSubs;
6876  {
6877  modelica_metatype _cref = NULL;
6878  modelica_metatype _cref2 = NULL;
6879  modelica_string _n = NULL;
6880  modelica_metatype _subs = NULL;
6881  modelica_metatype _s = NULL;
6882  volatile mmc_switch_type tmp3;
6883  int tmp4;
6884  tmp3 = 0;
6885  MMC_TRY_INTERNAL(mmc_jumper)
6886  tmp2_top:
6887  threadData->mmc_jumper = &new_mmc_jumper;
6888  for (; tmp3 < 4; tmp3++) {
6889  switch (MMC_SWITCH_CAST(tmp3)) {
6890  case 0: {
6891  if (!listEmpty(tmp3_2)) goto tmp2_end;
6892 
6893  _cref = tmp3_1;
6894  tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
6895 #line 5289 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6896  tmpMeta[0] = _cref;
6897 #line 6897 OMC_FILE
6898  goto tmp2_done;
6899  }
6900  case 1: {
6901  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
6902  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
6903  if (listEmpty(tmp3_2)) goto tmp2_end;
6904  tmpMeta[2] = MMC_CAR(tmp3_2);
6905  tmpMeta[3] = MMC_CDR(tmp3_2);
6906  if (!listEmpty(tmpMeta[3])) goto tmp2_end;
6907  _n = tmpMeta[1];
6908  _s = tmpMeta[2];
6909  tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
6910 #line 5291 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6911  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _n, _s);
6912 #line 5291 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6913  tmpMeta[0] = tmpMeta[1];
6914 #line 6914 OMC_FILE
6915  goto tmp2_done;
6916  }
6917  case 2: {
6918  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
6919  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
6920  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
6921  if (listEmpty(tmp3_2)) goto tmp2_end;
6922  tmpMeta[3] = MMC_CAR(tmp3_2);
6923  tmpMeta[4] = MMC_CDR(tmp3_2);
6924  _n = tmpMeta[1];
6925  _cref = tmpMeta[2];
6926  _s = tmpMeta[3];
6927  _subs = tmpMeta[4];
6928  tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
6929 #line 5294 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6930  _cref2 = omc_Absyn_crefInsertSubscriptLstLst2(threadData, _cref, _subs);
6931 #line 6931 OMC_FILE
6932 #line 5295 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6933  tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _n, _s, _cref2);
6934 #line 5295 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6935  tmpMeta[0] = tmpMeta[1];
6936 #line 6936 OMC_FILE
6937  goto tmp2_done;
6938  }
6939  case 3: {
6940  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
6941  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
6942 
6943  _cref = tmpMeta[1];
6944  _subs = tmp3_2;
6945  /* Pattern matching succeeded */
6946 #line 5299 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6947  _cref2 = omc_Absyn_crefInsertSubscriptLstLst2(threadData, _cref, _subs);
6948 #line 6948 OMC_FILE
6949 #line 5300 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6950  tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cref2);
6951 #line 6951 OMC_FILE
6952  goto tmp2_done;
6953  }
6954  }
6955  goto tmp2_end;
6956  tmp2_end: ;
6957  }
6958  goto goto_1;
6959  tmp2_done:
6960  (void)tmp3;
6961  MMC_RESTORE_INTERNAL(mmc_jumper);
6962  goto tmp2_done2;
6963  goto_1:;
6964  MMC_CATCH_INTERNAL(mmc_jumper);
6965  if (++tmp3 < 4) {
6966  goto tmp2_top;
6967  }
6968  MMC_THROW_INTERNAL();
6969  tmp2_done2:;
6970  }
6971  }
6972  _outCref = tmpMeta[0];
6973  _return: OMC_LABEL_UNUSED
6974  return _outCref;
6975 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_crefInsertSubscriptLstLst2(threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inSubs)
Definition: Absyn.c:6865
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the caller graph for this function:

◆ omc_Absyn_crefIsFullyQualified()

DLLExport modelica_boolean omc_Absyn_crefIsFullyQualified ( threadData_t threadData,
modelica_metatype  _inCref 
)

Definition at line 10601 of file Absyn.c.

10602 {
10603  modelica_boolean _outIsFullyQualified;
10604  modelica_boolean tmp1 = 0;
10605  MMC_SO();
10606  _tailrecursive: OMC_LABEL_UNUSED
10607 #line 10607 OMC_FILE
10608  { /* match expression */
10609  modelica_metatype tmp4_1;
10610  tmp4_1 = _inCref;
10611  {
10612  volatile mmc_switch_type tmp4;
10613  int tmp5;
10614  tmp4 = 0;
10615  for (; tmp4 < 2; tmp4++) {
10616  switch (MMC_SWITCH_CAST(tmp4)) {
10617  case 0: {
10618  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
10619 
10620  /* Pattern matching succeeded */
10621 #line 4386 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10622  tmp1 = 1;
10623 #line 10623 OMC_FILE
10624  goto tmp3_done;
10625  }
10626  case 1: {
10627 
10628  /* Pattern matching succeeded */
10629 #line 4387 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10630  tmp1 = 0;
10631 #line 10631 OMC_FILE
10632  goto tmp3_done;
10633  }
10634  }
10635  goto tmp3_end;
10636  tmp3_end: ;
10637  }
10638  goto goto_2;
10639  goto_2:;
10640  MMC_THROW_INTERNAL();
10641  goto tmp3_done;
10642  tmp3_done:;
10643  }
10644  }
10645  _outIsFullyQualified = tmp1;
10646  _return: OMC_LABEL_UNUSED
10647  return _outIsFullyQualified;
10648 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_crefIsIdent()

DLLExport modelica_boolean omc_Absyn_crefIsIdent ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11585 of file Absyn.c.

11586 {
11587  modelica_boolean _outIsIdent;
11588  modelica_boolean tmp1 = 0;
11589  MMC_SO();
11590  _tailrecursive: OMC_LABEL_UNUSED
11591 #line 11591 OMC_FILE
11592  { /* match expression */
11593  modelica_metatype tmp4_1;
11594  tmp4_1 = _inComponentRef;
11595  {
11596  volatile mmc_switch_type tmp4;
11597  int tmp5;
11598  tmp4 = 0;
11599  for (; tmp4 < 2; tmp4++) {
11600  switch (MMC_SWITCH_CAST(tmp4)) {
11601  case 0: {
11602  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
11603 
11604  /* Pattern matching succeeded */
11605 #line 4147 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11606  tmp1 = 1;
11607 #line 11607 OMC_FILE
11608  goto tmp3_done;
11609  }
11610  case 1: {
11611 
11612  /* Pattern matching succeeded */
11613 #line 4148 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11614  tmp1 = 0;
11615 #line 11615 OMC_FILE
11616  goto tmp3_done;
11617  }
11618  }
11619  goto tmp3_end;
11620  tmp3_end: ;
11621  }
11622  goto goto_2;
11623  goto_2:;
11624  MMC_THROW_INTERNAL();
11625  goto tmp3_done;
11626  tmp3_done:;
11627  }
11628  }
11629  _outIsIdent = tmp1;
11630  _return: OMC_LABEL_UNUSED
11631  return _outIsIdent;
11632 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_crefIsQual()

DLLExport modelica_boolean omc_Absyn_crefIsQual ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11521 of file Absyn.c.

11522 {
11523  modelica_boolean _outIsQual;
11524  modelica_boolean tmp1 = 0;
11525  MMC_SO();
11526  _tailrecursive: OMC_LABEL_UNUSED
11527 #line 11527 OMC_FILE
11528  { /* match expression */
11529  modelica_metatype tmp4_1;
11530  tmp4_1 = _inComponentRef;
11531  {
11532  int tmp4;
11533  {
11534  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
11535  case 4: {
11536 
11537  /* Pattern matching succeeded */
11538 #line 4158 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11539  tmp1 = 1;
11540 #line 11540 OMC_FILE
11541  goto tmp3_done;
11542  }
11543  case 3: {
11544 
11545  /* Pattern matching succeeded */
11546 #line 4159 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11547  tmp1 = 1;
11548 #line 11548 OMC_FILE
11549  goto tmp3_done;
11550  }
11551  default:
11552  tmp3_default: OMC_LABEL_UNUSED; {
11553 
11554  /* Pattern matching succeeded */
11555 #line 4160 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11556  tmp1 = 0;
11557 #line 11557 OMC_FILE
11558  goto tmp3_done;
11559  }
11560  }
11561  goto tmp3_end;
11562  tmp3_end: ;
11563  }
11564  goto goto_2;
11565  goto_2:;
11566  MMC_THROW_INTERNAL();
11567  goto tmp3_done;
11568  tmp3_done:;
11569  }
11570  }
11571  _outIsQual = tmp1;
11572  _return: OMC_LABEL_UNUSED
11573  return _outIsQual;
11574 }
signed char modelica_boolean
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_crefLastIdent()

DLLExport modelica_string omc_Absyn_crefLastIdent ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11718 of file Absyn.c.

11719 {
11720  modelica_string _outIdent = NULL;
11721  modelica_string tmp1 = 0;
11722  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
11723  MMC_SO();
11724  _tailrecursive: OMC_LABEL_UNUSED
11725 #line 11725 OMC_FILE
11726  { /* match expression */
11727  modelica_metatype tmp4_1;
11728  tmp4_1 = _inComponentRef;
11729  {
11730  modelica_metatype _cref = NULL;
11731  modelica_string _id = NULL;
11732  int tmp4;
11733  {
11734  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
11735  case 5: {
11736  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
11737  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
11738 
11739  _id = tmpMeta[0];
11740  /* Pattern matching succeeded */
11741 #line 4119 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11742  tmp1 = _id;
11743 #line 11743 OMC_FILE
11744  goto tmp3_done;
11745  }
11746  case 4: {
11747  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
11748  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
11749  _cref = tmpMeta[0];
11750  /* Pattern matching succeeded */
11751 #line 4120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11752  /* Tail recursive call */
11753 #line 4120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11754  _inComponentRef = _cref;
11755 #line 4120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11756  goto _tailrecursive;
11757 #line 4120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11758  /* TODO: Make sure any eventual dead code below is never generated */
11759 #line 11759 OMC_FILE
11760  goto tmp3_done;
11761  }
11762  case 3: {
11763  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
11764  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
11765  _cref = tmpMeta[0];
11766  /* Pattern matching succeeded */
11767 #line 4121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11768  /* Tail recursive call */
11769 #line 4121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11770  _inComponentRef = _cref;
11771 #line 4121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11772  goto _tailrecursive;
11773 #line 4121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11774  /* TODO: Make sure any eventual dead code below is never generated */
11775 #line 11775 OMC_FILE
11776  goto tmp3_done;
11777  }
11778  }
11779  goto tmp3_end;
11780  tmp3_end: ;
11781  }
11782  goto goto_2;
11783  goto_2:;
11784  MMC_THROW_INTERNAL();
11785  goto tmp3_done;
11786  tmp3_done:;
11787  }
11788  }
11789  _outIdent = tmp1;
11790  _return: OMC_LABEL_UNUSED
11791  return _outIdent;
11792 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_crefLastSubs()

DLLExport modelica_metatype omc_Absyn_crefLastSubs ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11446 of file Absyn.c.

11447 {
11448  modelica_metatype _outSubscriptLst = NULL;
11449  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
11450  MMC_SO();
11451  _tailrecursive: OMC_LABEL_UNUSED
11452 #line 11452 OMC_FILE
11453  { /* match expression */
11454  modelica_metatype tmp3_1;
11455  tmp3_1 = _inComponentRef;
11456  {
11457  modelica_metatype _subs = NULL;
11458  modelica_metatype _cr = NULL;
11459  int tmp3;
11460  {
11461  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
11462  case 5: {
11463  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
11464  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
11465  _subs = tmpMeta[1];
11466  /* Pattern matching succeeded */
11467 #line 4174 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11468  tmpMeta[0] = _subs;
11469 #line 11469 OMC_FILE
11470  goto tmp2_done;
11471  }
11472  case 4: {
11473  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
11474  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
11475  _cr = tmpMeta[1];
11476  /* Pattern matching succeeded */
11477 #line 4177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11478  /* Tail recursive call */
11479 #line 4177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11480  _inComponentRef = _cr;
11481 #line 4177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11482  goto _tailrecursive;
11483 #line 4177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11484  /* TODO: Make sure any eventual dead code below is never generated */
11485 #line 11485 OMC_FILE
11486  goto tmp2_done;
11487  }
11488  case 3: {
11489  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
11490  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11491  _cr = tmpMeta[1];
11492  /* Pattern matching succeeded */
11493 #line 4182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11494  /* Tail recursive call */
11495 #line 4182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11496  _inComponentRef = _cr;
11497 #line 4182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11498  goto _tailrecursive;
11499 #line 4182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11500  /* TODO: Make sure any eventual dead code below is never generated */
11501 #line 11501 OMC_FILE
11502  goto tmp2_done;
11503  }
11504  }
11505  goto tmp2_end;
11506  tmp2_end: ;
11507  }
11508  goto goto_1;
11509  goto_1:;
11510  MMC_THROW_INTERNAL();
11511  goto tmp2_done;
11512  tmp2_done:;
11513  }
11514  }
11515  _outSubscriptLst = tmpMeta[0];
11516  _return: OMC_LABEL_UNUSED
11517  return _outSubscriptLst;
11518 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_crefMakeFullyQualified()

DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 10549 of file Absyn.c.

10550 {
10551  modelica_metatype _outComponentRef = NULL;
10552  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
10553  MMC_SO();
10554  _tailrecursive: OMC_LABEL_UNUSED
10555 #line 10555 OMC_FILE
10556  { /* match expression */
10557  modelica_metatype tmp3_1;
10558  tmp3_1 = _inComponentRef;
10559  {
10560  volatile mmc_switch_type tmp3;
10561  int tmp4;
10562  tmp3 = 0;
10563  for (; tmp3 < 2; tmp3++) {
10564  switch (MMC_SWITCH_CAST(tmp3)) {
10565  case 0: {
10566  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
10567 
10568  /* Pattern matching succeeded */
10569 #line 4397 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10570  tmpMeta[0] = _inComponentRef;
10571 #line 10571 OMC_FILE
10572  goto tmp2_done;
10573  }
10574  case 1: {
10575 
10576  /* Pattern matching succeeded */
10577 #line 4398 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10578  tmpMeta[1] = mmc_mk_box2(3, &Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc, _inComponentRef);
10579 #line 4398 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10580  tmpMeta[0] = tmpMeta[1];
10581 #line 10581 OMC_FILE
10582  goto tmp2_done;
10583  }
10584  }
10585  goto tmp2_end;
10586  tmp2_end: ;
10587  }
10588  goto goto_1;
10589  goto_1:;
10590  MMC_THROW_INTERNAL();
10591  goto tmp2_done;
10592  tmp2_done:;
10593  }
10594  }
10595  _outComponentRef = tmpMeta[0];
10596  _return: OMC_LABEL_UNUSED
10597  return _outComponentRef;
10598 }
float mmc_switch_type
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_crefPrefixOf()

DLLExport modelica_boolean omc_Absyn_crefPrefixOf ( threadData_t threadData,
modelica_metatype  _prefixCr,
modelica_metatype  _cr 
)

Definition at line 14470 of file Absyn.c.

14471 {
14472  modelica_boolean _out;
14473  modelica_boolean tmp1 = 0;
14474  MMC_SO();
14475  _tailrecursive: OMC_LABEL_UNUSED
14476 #line 14476 OMC_FILE
14477  { /* matchcontinue expression */
14478  {
14479  volatile mmc_switch_type tmp4;
14480  int tmp5;
14481  tmp4 = 0;
14482  MMC_TRY_INTERNAL(mmc_jumper)
14483  tmp3_top:
14484  threadData->mmc_jumper = &new_mmc_jumper;
14485  for (; tmp4 < 3; tmp4++) {
14486  switch (MMC_SWITCH_CAST(tmp4)) {
14487  case 0: {
14488  modelica_boolean tmp6;
14489  /* Pattern matching succeeded */
14490 #line 3298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14491  /* Pattern-matching assignment */
14492 #line 3298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14493  tmp6 = omc_Absyn_crefEqualNoSubs(threadData, _prefixCr, _cr);
14494 #line 3298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14495  if (1 != tmp6) goto goto_2;
14496 #line 14496 OMC_FILE
14497 #line 3299 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14498  tmp1 = 1;
14499 #line 14499 OMC_FILE
14500  goto tmp3_done;
14501  }
14502  case 1: {
14503  /* Pattern matching succeeded */
14504 #line 3301 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14505  tmp1 = omc_Absyn_crefPrefixOf(threadData, _prefixCr, omc_Absyn_crefStripLast(threadData, _cr));
14506 #line 14506 OMC_FILE
14507  goto tmp3_done;
14508  }
14509  case 2: {
14510  /* Pattern matching succeeded */
14511 #line 3302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14512  tmp1 = 0;
14513 #line 14513 OMC_FILE
14514  goto tmp3_done;
14515  }
14516  }
14517  goto tmp3_end;
14518  tmp3_end: ;
14519  }
14520  goto goto_2;
14521  tmp3_done:
14522  (void)tmp4;
14523  MMC_RESTORE_INTERNAL(mmc_jumper);
14524  goto tmp3_done2;
14525  goto_2:;
14526  MMC_CATCH_INTERNAL(mmc_jumper);
14527  if (++tmp4 < 3) {
14528  goto tmp3_top;
14529  }
14530  MMC_THROW_INTERNAL();
14531  tmp3_done2:;
14532  }
14533  }
14534  _out = tmp1;
14535  _return: OMC_LABEL_UNUSED
14536  return _out;
14537 }
DLLExport modelica_metatype omc_Absyn_crefStripLast(threadData_t *threadData, modelica_metatype _inCref)
Definition: Absyn.c:12319
DLLExport modelica_boolean omc_Absyn_crefEqualNoSubs(threadData_t *threadData, modelica_metatype _cr1, modelica_metatype _cr2)
Definition: Absyn.c:9702
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_Absyn_crefPrefixOf(threadData_t *threadData, modelica_metatype _prefixCr, modelica_metatype _cr)
Definition: Absyn.c:14470
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_crefRemovePrefix()

DLLExport modelica_metatype omc_Absyn_crefRemovePrefix ( threadData_t threadData,
modelica_metatype  _prefixCr,
modelica_metatype  _cr 
)

Definition at line 14139 of file Absyn.c.

14140 {
14141  modelica_metatype _out = NULL;
14142  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
14143  MMC_SO();
14144  _tailrecursive: OMC_LABEL_UNUSED
14145 #line 14145 OMC_FILE
14146  { /* match expression */
14147  modelica_metatype tmp3_1;modelica_metatype tmp3_2;
14148  tmp3_1 = _prefixCr;
14149  tmp3_2 = _cr;
14150  {
14151  modelica_string _prefixIdent = NULL;
14152  modelica_string _ident = NULL;
14153  modelica_metatype _prefixRestCr = NULL;
14154  modelica_metatype _restCr = NULL;
14155  volatile mmc_switch_type tmp3;
14156  int tmp4;
14157  tmp3 = 0;
14158  for (; tmp3 < 4; tmp3++) {
14159  switch (MMC_SWITCH_CAST(tmp3)) {
14160  case 0: {
14161  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
14162  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14163  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,1) == 0) goto tmp2_end;
14164  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
14165  _prefixRestCr = tmpMeta[1];
14166  _restCr = tmpMeta[2];
14167  /* Pattern matching succeeded */
14168 #line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14169  /* Tail recursive call */
14170 #line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14171  _prefixCr = _prefixRestCr;
14172 #line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14173  _cr = _restCr;
14174 #line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14175  goto _tailrecursive;
14176 #line 3384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14177  /* TODO: Make sure any eventual dead code below is never generated */
14178 #line 14178 OMC_FILE
14179  goto tmp2_done;
14180  }
14181  case 1: {
14182  modelica_boolean tmp5;
14183  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
14184  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14185  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
14186  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,1,3) == 0) goto tmp2_end;
14187  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
14188  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 4));
14189  _prefixIdent = tmpMeta[1];
14190  _prefixRestCr = tmpMeta[2];
14191  _ident = tmpMeta[3];
14192  _restCr = tmpMeta[4];
14193  /* Pattern matching succeeded */
14194 #line 3389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14195  /* Pattern-matching assignment */
14196 #line 3389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14197  tmp5 = (stringEqual(_prefixIdent, _ident));
14198 #line 3389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14199  if (1 != tmp5) goto goto_1;
14200 #line 14200 OMC_FILE
14201 #line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14202  /* Tail recursive call */
14203 #line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14204  _prefixCr = _prefixRestCr;
14205 #line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14206  _cr = _restCr;
14207 #line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14208  goto _tailrecursive;
14209 #line 3390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14210  /* TODO: Make sure any eventual dead code below is never generated */
14211 #line 14211 OMC_FILE
14212  goto tmp2_done;
14213  }
14214  case 2: {
14215  modelica_boolean tmp6;
14216  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
14217  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14218  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,1,3) == 0) goto tmp2_end;
14219  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
14220  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 4));
14221  _prefixIdent = tmpMeta[1];
14222  _ident = tmpMeta[2];
14223  _restCr = tmpMeta[3];
14224  /* Pattern matching succeeded */
14225 #line 3395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14226  /* Pattern-matching assignment */
14227 #line 3395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14228  tmp6 = (stringEqual(_prefixIdent, _ident));
14229 #line 3395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14230  if (1 != tmp6) goto goto_1;
14231 #line 14231 OMC_FILE
14232 #line 3396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14233  tmpMeta[0] = _restCr;
14234 #line 14234 OMC_FILE
14235  goto tmp2_done;
14236  }
14237  case 3: {
14238  modelica_boolean tmp7;
14239  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
14240  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14241  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,2,2) == 0) goto tmp2_end;
14242  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
14243 
14244  _prefixIdent = tmpMeta[1];
14245  _ident = tmpMeta[2];
14246  /* Pattern matching succeeded */
14247 #line 3400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14248  /* Pattern-matching assignment */
14249 #line 3400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14250  tmp7 = (stringEqual(_prefixIdent, _ident));
14251 #line 3400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14252  if (1 != tmp7) goto goto_1;
14253 #line 14253 OMC_FILE
14254 #line 3401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14255  tmpMeta[0] = _OMC_LIT56;
14256 #line 14256 OMC_FILE
14257  goto tmp2_done;
14258  }
14259  }
14260  goto tmp2_end;
14261  tmp2_end: ;
14262  }
14263  goto goto_1;
14264  goto_1:;
14265  MMC_THROW_INTERNAL();
14266  goto tmp2_done;
14267  tmp2_done:;
14268  }
14269  }
14270  _out = tmpMeta[0];
14271  _return: OMC_LABEL_UNUSED
14272  return _out;
14273 }
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_crefReplaceFirstIdent()

DLLExport modelica_metatype omc_Absyn_crefReplaceFirstIdent ( threadData_t threadData,
modelica_metatype  _icref,
modelica_metatype  _replPath 
)

Definition at line 14698 of file Absyn.c.

14699 {
14700  modelica_metatype _outCref = NULL;
14701  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
14702  MMC_SO();
14703  _tailrecursive: OMC_LABEL_UNUSED
14704 #line 14704 OMC_FILE
14705  { /* match expression */
14706  modelica_metatype tmp3_1;
14707  tmp3_1 = _icref;
14708  {
14709  modelica_metatype _subs = NULL;
14710  modelica_metatype _cr = NULL;
14711  modelica_metatype _cref = NULL;
14712  int tmp3;
14713  {
14714  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
14715  case 3: {
14716  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
14717  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14718  _cr = tmpMeta[1];
14719  /* Pattern matching succeeded */
14720 #line 3246 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14721  _cr = omc_Absyn_crefReplaceFirstIdent(threadData, _cr, _replPath);
14722 #line 14722 OMC_FILE
14723 #line 3247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14724  tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cr);
14725 #line 14725 OMC_FILE
14726  goto tmp2_done;
14727  }
14728  case 4: {
14729  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
14730  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
14731  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
14732  _subs = tmpMeta[1];
14733  _cr = tmpMeta[2];
14734  /* Pattern matching succeeded */
14735 #line 3250 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14736  _cref = omc_Absyn_pathToCref(threadData, _replPath);
14737 #line 14737 OMC_FILE
14738 
14739 #line 3251 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14740  _cref = omc_Absyn_addSubscriptsLast(threadData, _cref, _subs);
14741 #line 14741 OMC_FILE
14742 #line 3252 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14743  tmpMeta[0] = omc_Absyn_joinCrefs(threadData, _cref, _cr);
14744 #line 14744 OMC_FILE
14745  goto tmp2_done;
14746  }
14747  case 5: {
14748  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
14749  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
14750  _subs = tmpMeta[1];
14751  /* Pattern matching succeeded */
14752 #line 3255 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14753  _cref = omc_Absyn_pathToCref(threadData, _replPath);
14754 #line 14754 OMC_FILE
14755 #line 3256 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14756  tmpMeta[0] = omc_Absyn_addSubscriptsLast(threadData, _cref, _subs);
14757 #line 14757 OMC_FILE
14758  goto tmp2_done;
14759  }
14760  }
14761  goto tmp2_end;
14762  tmp2_end: ;
14763  }
14764  goto goto_1;
14765  goto_1:;
14766  MMC_THROW_INTERNAL();
14767  goto tmp2_done;
14768  tmp2_done:;
14769  }
14770  }
14771  _outCref = tmpMeta[0];
14772  _return: OMC_LABEL_UNUSED
14773  return _outCref;
14774 }
DLLExport modelica_metatype omc_Absyn_addSubscriptsLast(threadData_t *threadData, modelica_metatype _icr, modelica_metatype _i)
Definition: Absyn.c:14777
DLLExport modelica_metatype omc_Absyn_crefReplaceFirstIdent(threadData_t *threadData, modelica_metatype _icref, modelica_metatype _replPath)
Definition: Absyn.c:14698
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
DLLExport modelica_metatype omc_Absyn_pathToCref(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:11873
DLLExport modelica_metatype omc_Absyn_joinCrefs(threadData_t *threadData, modelica_metatype _inComponentRef1, modelica_metatype _inComponentRef2)
Definition: Absyn.c:10901
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_crefSecondIdent()

DLLExport modelica_string omc_Absyn_crefSecondIdent ( threadData_t threadData,
modelica_metatype  _cref 
)

Definition at line 10783 of file Absyn.c.

10784 {
10785  modelica_string _ident = NULL;
10786  modelica_string tmp1 = 0;
10787  MMC_SO();
10788  _tailrecursive: OMC_LABEL_UNUSED
10789 #line 10789 OMC_FILE
10790  { /* match expression */
10791  modelica_metatype tmp4_1;
10792  tmp4_1 = _cref;
10793  {
10794  volatile mmc_switch_type tmp4;
10795  int tmp5;
10796  tmp4 = 0;
10797  for (; tmp4 < 2; tmp4++) {
10798  switch (MMC_SWITCH_CAST(tmp4)) {
10799  case 0: {
10800  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
10801 
10802  /* Pattern matching succeeded */
10803 #line 4352 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10804  tmp1 = omc_Absyn_crefFirstIdent(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 4))));
10805 #line 10805 OMC_FILE
10806  goto tmp3_done;
10807  }
10808  case 1: {
10809  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
10810 
10811  /* Pattern matching succeeded */
10812 #line 4353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10813  /* Tail recursive call */
10814 #line 4353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10815  _cref = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_cref), 2)));
10816 #line 4353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10817  goto _tailrecursive;
10818 #line 4353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10819  /* TODO: Make sure any eventual dead code below is never generated */
10820 #line 10820 OMC_FILE
10821  goto tmp3_done;
10822  }
10823  }
10824  goto tmp3_end;
10825  tmp3_end: ;
10826  }
10827  goto goto_2;
10828  goto_2:;
10829  MMC_THROW_INTERNAL();
10830  goto tmp3_done;
10831  tmp3_done:;
10832  }
10833  }
10834  _ident = tmp1;
10835  _return: OMC_LABEL_UNUSED
10836  return _ident;
10837 }
modelica_metatype modelica_string
float mmc_switch_type
void * modelica_metatype
DLLExport modelica_string omc_Absyn_crefFirstIdent(threadData_t *threadData, modelica_metatype _inCref)
Definition: Absyn.c:10840
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_crefSetLastSubs()

DLLExport modelica_metatype omc_Absyn_crefSetLastSubs ( threadData_t threadData,
modelica_metatype  _inCref,
modelica_metatype  _inSubscripts 
)

Definition at line 11363 of file Absyn.c.

11364 {
11365  modelica_metatype _outCref = NULL;
11366  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
11367  MMC_SO();
11368  _tailrecursive: OMC_LABEL_UNUSED
11369  _outCref = _inCref;
11370 #line 11370 OMC_FILE
11371  { /* match expression */
11372  modelica_metatype tmp3_1;
11373  tmp3_1 = _outCref;
11374  {
11375  int tmp3;
11376  {
11377  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
11378  case 5: {
11379 
11380  /* Pattern matching succeeded */
11381 #line 4196 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11382  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(4));
11383 #line 4196 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11384  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outCref), 4*sizeof(modelica_metatype));
11385 #line 4196 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11386  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[3] = _inSubscripts;
11387 #line 4196 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11388  _outCref = tmpMeta[1];
11389 #line 11389 OMC_FILE
11390 #line 4197 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11391  tmpMeta[0] = _outCref;
11392 #line 11392 OMC_FILE
11393  goto tmp2_done;
11394  }
11395  case 4: {
11396 
11397  /* Pattern matching succeeded */
11398 #line 4202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11399  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(5));
11400 #line 4202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11401  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outCref), 5*sizeof(modelica_metatype));
11402 #line 4202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11403  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[4] = omc_Absyn_crefSetLastSubs(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outCref), 4))), _inSubscripts);
11404 #line 4202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11405  _outCref = tmpMeta[1];
11406 #line 11406 OMC_FILE
11407 #line 4203 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11408  tmpMeta[0] = _outCref;
11409 #line 11409 OMC_FILE
11410  goto tmp2_done;
11411  }
11412  case 3: {
11413 
11414  /* Pattern matching succeeded */
11415 #line 4208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11416  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(3));
11417 #line 4208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11418  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outCref), 3*sizeof(modelica_metatype));
11419 #line 4208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11420  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = omc_Absyn_crefSetLastSubs(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outCref), 2))), _inSubscripts);
11421 #line 4208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11422  _outCref = tmpMeta[1];
11423 #line 11423 OMC_FILE
11424 #line 4209 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11425  tmpMeta[0] = _outCref;
11426 #line 11426 OMC_FILE
11427  goto tmp2_done;
11428  }
11429  }
11430  goto tmp2_end;
11431  tmp2_end: ;
11432  }
11433  goto goto_1;
11434  goto_1:;
11435  MMC_THROW_INTERNAL();
11436  goto tmp2_done;
11437  tmp2_done:;
11438  }
11439  }
11440  _outCref = tmpMeta[0];
11441  _return: OMC_LABEL_UNUSED
11442  return _outCref;
11443 }
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
DLLExport modelica_metatype omc_Absyn_crefSetLastSubs(threadData_t *threadData, modelica_metatype _inCref, modelica_metatype _inSubscripts)
Definition: Absyn.c:11363
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_crefString()

DLLExport modelica_string omc_Absyn_crefString ( threadData_t threadData,
modelica_metatype  _inCr 
)

Definition at line 4365 of file Absyn.c.

4366 {
4367  modelica_string _outStr = NULL;
4368  MMC_SO();
4369  _tailrecursive: OMC_LABEL_UNUSED
4370 #line 5898 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4371  _outStr = omc_Dump_printComponentRefStr(threadData, _inCr);
4372 #line 4372 OMC_FILE
4373  _return: OMC_LABEL_UNUSED
4374  return _outStr;
4375 }
modelica_metatype modelica_string
DLLExport modelica_string omc_Dump_printComponentRefStr(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Dump.c:12785
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_crefStringIgnoreSubs()

DLLExport modelica_string omc_Absyn_crefStringIgnoreSubs ( threadData_t threadData,
modelica_metatype  _inCr 
)

Definition at line 4263 of file Absyn.c.

4264 {
4265  modelica_string _outStr = NULL;
4266  modelica_metatype _p = NULL;
4267  MMC_SO();
4268  _tailrecursive: OMC_LABEL_UNUSED
4269 #line 5943 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4270  _p = omc_Absyn_crefToPathIgnoreSubs(threadData, _inCr);
4271 #line 4271 OMC_FILE
4272 
4273 #line 5944 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4274  _outStr = omc_Absyn_pathString(threadData, omc_Absyn_makeNotFullyQualified(threadData, _p), _OMC_LIT1, 1, 0);
4275 #line 4275 OMC_FILE
4276  _return: OMC_LABEL_UNUSED
4277  return _outStr;
4278 }
modelica_metatype modelica_string
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_crefToPathIgnoreSubs(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:11953
DLLExport modelica_metatype omc_Absyn_makeNotFullyQualified(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:8283
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_crefStripFirst()

DLLExport modelica_metatype omc_Absyn_crefStripFirst ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 10659 of file Absyn.c.

10660 {
10661  modelica_metatype _outComponentRef = NULL;
10662  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
10663  MMC_SO();
10664  _tailrecursive: OMC_LABEL_UNUSED
10665 #line 10665 OMC_FILE
10666  { /* match expression */
10667  modelica_metatype tmp3_1;
10668  tmp3_1 = _inComponentRef;
10669  {
10670  modelica_metatype _cr = NULL;
10671  volatile mmc_switch_type tmp3;
10672  int tmp4;
10673  tmp3 = 0;
10674  for (; tmp3 < 2; tmp3++) {
10675  switch (MMC_SWITCH_CAST(tmp3)) {
10676  case 0: {
10677  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
10678  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
10679  _cr = tmpMeta[1];
10680  /* Pattern matching succeeded */
10681 #line 4376 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10682  tmpMeta[0] = _cr;
10683 #line 10683 OMC_FILE
10684  goto tmp2_done;
10685  }
10686  case 1: {
10687  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
10688  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
10689  _cr = tmpMeta[1];
10690  /* Pattern matching succeeded */
10691 #line 4377 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10692  /* Tail recursive call */
10693 #line 4377 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10694  _inComponentRef = _cr;
10695 #line 4377 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10696  goto _tailrecursive;
10697 #line 4377 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10698  /* TODO: Make sure any eventual dead code below is never generated */
10699 #line 10699 OMC_FILE
10700  goto tmp2_done;
10701  }
10702  }
10703  goto tmp2_end;
10704  tmp2_end: ;
10705  }
10706  goto goto_1;
10707  goto_1:;
10708  MMC_THROW_INTERNAL();
10709  goto tmp2_done;
10710  tmp2_done:;
10711  }
10712  }
10713  _outComponentRef = tmpMeta[0];
10714  _return: OMC_LABEL_UNUSED
10715  return _outComponentRef;
10716 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_crefStripLast()

DLLExport modelica_metatype omc_Absyn_crefStripLast ( threadData_t threadData,
modelica_metatype  _inCref 
)

Definition at line 12319 of file Absyn.c.

12320 {
12321  modelica_metatype _outCref = NULL;
12322  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
12323  MMC_SO();
12324  _tailrecursive: OMC_LABEL_UNUSED
12325 #line 12325 OMC_FILE
12326  { /* match expression */
12327  modelica_metatype tmp3_1;
12328  tmp3_1 = _inCref;
12329  {
12330  modelica_string _str = NULL;
12331  modelica_metatype _c_1 = NULL;
12332  modelica_metatype _c = NULL;
12333  modelica_metatype _subs = NULL;
12334  volatile mmc_switch_type tmp3;
12335  int tmp4;
12336  tmp3 = 0;
12337  for (; tmp3 < 4; tmp3++) {
12338  switch (MMC_SWITCH_CAST(tmp3)) {
12339  case 0: {
12340  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
12341 
12342  /* Pattern matching succeeded */
12343 #line 3934 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12344  goto goto_1;
12345 #line 12345 OMC_FILE
12346  goto tmp2_done;
12347  }
12348  case 1: {
12349  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
12350  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12351  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12352  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
12353  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],2,2) == 0) goto tmp2_end;
12354 
12355  _str = tmpMeta[1];
12356  _subs = tmpMeta[2];
12357  /* Pattern matching succeeded */
12358 #line 3935 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12359  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _str, _subs);
12360 #line 3935 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12361  tmpMeta[0] = tmpMeta[1];
12362 #line 12362 OMC_FILE
12363  goto tmp2_done;
12364  }
12365  case 2: {
12366  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
12367  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12368  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12369  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
12370  _str = tmpMeta[1];
12371  _subs = tmpMeta[2];
12372  _c = tmpMeta[3];
12373  /* Pattern matching succeeded */
12374 #line 3938 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12375  _c_1 = omc_Absyn_crefStripLast(threadData, _c);
12376 #line 12376 OMC_FILE
12377 #line 3939 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12378  tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _str, _subs, _c_1);
12379 #line 3939 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12380  tmpMeta[0] = tmpMeta[1];
12381 #line 12381 OMC_FILE
12382  goto tmp2_done;
12383  }
12384  case 3: {
12385  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
12386  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12387  _c = tmpMeta[1];
12388  /* Pattern matching succeeded */
12389 #line 3943 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12390  _c_1 = omc_Absyn_crefStripLast(threadData, _c);
12391 #line 12391 OMC_FILE
12392 #line 3944 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12393  tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _c_1);
12394 #line 12394 OMC_FILE
12395  goto tmp2_done;
12396  }
12397  }
12398  goto tmp2_end;
12399  tmp2_end: ;
12400  }
12401  goto goto_1;
12402  goto_1:;
12403  MMC_THROW_INTERNAL();
12404  goto tmp2_done;
12405  tmp2_done:;
12406  }
12407  }
12408  _outCref = tmpMeta[0];
12409  _return: OMC_LABEL_UNUSED
12410  return _outCref;
12411 }
DLLExport modelica_metatype omc_Absyn_crefStripLast(threadData_t *threadData, modelica_metatype _inCref)
Definition: Absyn.c:12319
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
modelica_metatype modelica_string
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_crefStripLastSubs()

DLLExport modelica_metatype omc_Absyn_crefStripLastSubs ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11009 of file Absyn.c.

11010 {
11011  modelica_metatype _outComponentRef = NULL;
11012  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
11013  MMC_SO();
11014  _tailrecursive: OMC_LABEL_UNUSED
11015 #line 11015 OMC_FILE
11016  { /* match expression */
11017  modelica_metatype tmp3_1;
11018  tmp3_1 = _inComponentRef;
11019  {
11020  modelica_string _id = NULL;
11021  modelica_metatype _s = NULL;
11022  modelica_metatype _cr_1 = NULL;
11023  modelica_metatype _cr = NULL;
11024  int tmp3;
11025  {
11026  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
11027  case 5: {
11028  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
11029  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11030 
11031  _id = tmpMeta[1];
11032  /* Pattern matching succeeded */
11033 #line 4294 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11034  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
11035 #line 4294 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11036  tmpMeta[2] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, tmpMeta[1]);
11037 #line 4294 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11038  tmpMeta[0] = tmpMeta[2];
11039 #line 11039 OMC_FILE
11040  goto tmp2_done;
11041  }
11042  case 4: {
11043  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
11044  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11045  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
11046  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
11047  _id = tmpMeta[1];
11048  _s = tmpMeta[2];
11049  _cr = tmpMeta[3];
11050  /* Pattern matching succeeded */
11051 #line 4297 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11052  _cr_1 = omc_Absyn_crefStripLastSubs(threadData, _cr);
11053 #line 11053 OMC_FILE
11054 #line 4298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11055  tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _s, _cr_1);
11056 #line 4298 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11057  tmpMeta[0] = tmpMeta[1];
11058 #line 11058 OMC_FILE
11059  goto tmp2_done;
11060  }
11061  case 3: {
11062  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
11063  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11064  _cr = tmpMeta[1];
11065  /* Pattern matching succeeded */
11066 #line 4302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11067  _cr_1 = omc_Absyn_crefStripLastSubs(threadData, _cr);
11068 #line 11068 OMC_FILE
11069 #line 4303 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11070  tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cr_1);
11071 #line 11071 OMC_FILE
11072  goto tmp2_done;
11073  }
11074  }
11075  goto tmp2_end;
11076  tmp2_end: ;
11077  }
11078  goto goto_1;
11079  goto_1:;
11080  MMC_THROW_INTERNAL();
11081  goto tmp2_done;
11082  tmp2_done:;
11083  }
11084  }
11085  _outComponentRef = tmpMeta[0];
11086  _return: OMC_LABEL_UNUSED
11087  return _outComponentRef;
11088 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
modelica_metatype modelica_string
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_crefStripLastSubs(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:11009
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_crefToPath()

DLLExport modelica_metatype omc_Absyn_crefToPath ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 12077 of file Absyn.c.

12078 {
12079  modelica_metatype _outPath = NULL;
12080  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
12081  MMC_SO();
12082  _tailrecursive: OMC_LABEL_UNUSED
12083 #line 12083 OMC_FILE
12084  { /* match expression */
12085  modelica_metatype tmp3_1;
12086  tmp3_1 = _inComponentRef;
12087  {
12088  modelica_string _i = NULL;
12089  modelica_metatype _p = NULL;
12090  modelica_metatype _c = NULL;
12091  int tmp3;
12092  {
12093  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
12094  case 5: {
12095  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
12096  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12097  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12098  if (!listEmpty(tmpMeta[2])) goto tmp2_end;
12099  _i = tmpMeta[1];
12100  /* Pattern matching succeeded */
12101 #line 4004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12102  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _i);
12103 #line 4004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12104  tmpMeta[0] = tmpMeta[1];
12105 #line 12105 OMC_FILE
12106  goto tmp2_done;
12107  }
12108  case 4: {
12109  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
12110  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12111  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12112  if (!listEmpty(tmpMeta[2])) goto tmp2_end;
12113  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
12114  _i = tmpMeta[1];
12115  _c = tmpMeta[3];
12116  /* Pattern matching succeeded */
12117 #line 4007 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12118  _p = omc_Absyn_crefToPath(threadData, _c);
12119 #line 12119 OMC_FILE
12120 #line 4008 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12121  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _i, _p);
12122 #line 4008 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12123  tmpMeta[0] = tmpMeta[1];
12124 #line 12124 OMC_FILE
12125  goto tmp2_done;
12126  }
12127  case 3: {
12128  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
12129  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12130  _c = tmpMeta[1];
12131  /* Pattern matching succeeded */
12132 #line 4012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12133  _p = omc_Absyn_crefToPath(threadData, _c);
12134 #line 12134 OMC_FILE
12135 #line 4013 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12136  tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
12137 #line 4013 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12138  tmpMeta[0] = tmpMeta[1];
12139 #line 12139 OMC_FILE
12140  goto tmp2_done;
12141  }
12142  }
12143  goto tmp2_end;
12144  tmp2_end: ;
12145  }
12146  goto goto_1;
12147  goto_1:;
12148  MMC_THROW_INTERNAL();
12149  goto tmp2_done;
12150  tmp2_done:;
12151  }
12152  }
12153  _outPath = tmpMeta[0];
12154  _return: OMC_LABEL_UNUSED
12155  return _outPath;
12156 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
DLLExport modelica_metatype omc_Absyn_crefToPath(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:12077
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_FULLYQUALIFIED__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_crefToPathIgnoreSubs()

DLLExport modelica_metatype omc_Absyn_crefToPathIgnoreSubs ( threadData_t threadData,
modelica_metatype  _inComponentRef 
)

Definition at line 11953 of file Absyn.c.

11954 {
11955  modelica_metatype _outPath = NULL;
11956  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
11957  MMC_SO();
11958  _tailrecursive: OMC_LABEL_UNUSED
11959 #line 11959 OMC_FILE
11960  { /* match expression */
11961  modelica_metatype tmp3_1;
11962  tmp3_1 = _inComponentRef;
11963  {
11964  modelica_string _i = NULL;
11965  modelica_metatype _p = NULL;
11966  modelica_metatype _c = NULL;
11967  int tmp3;
11968  {
11969  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
11970  case 5: {
11971  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
11972  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11973 
11974  _i = tmpMeta[1];
11975  /* Pattern matching succeeded */
11976 #line 4041 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11977  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _i);
11978 #line 4041 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11979  tmpMeta[0] = tmpMeta[1];
11980 #line 11980 OMC_FILE
11981  goto tmp2_done;
11982  }
11983  case 4: {
11984  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
11985  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11986  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
11987  _i = tmpMeta[1];
11988  _c = tmpMeta[2];
11989  /* Pattern matching succeeded */
11990 #line 4045 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11991  _p = omc_Absyn_crefToPathIgnoreSubs(threadData, _c);
11992 #line 11992 OMC_FILE
11993 #line 4046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11994  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _i, _p);
11995 #line 4046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11996  tmpMeta[0] = tmpMeta[1];
11997 #line 11997 OMC_FILE
11998  goto tmp2_done;
11999  }
12000  case 3: {
12001  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
12002  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12003  _c = tmpMeta[1];
12004  /* Pattern matching succeeded */
12005 #line 4051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12006  _p = omc_Absyn_crefToPathIgnoreSubs(threadData, _c);
12007 #line 12007 OMC_FILE
12008 #line 4052 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12009  tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
12010 #line 4052 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12011  tmpMeta[0] = tmpMeta[1];
12012 #line 12012 OMC_FILE
12013  goto tmp2_done;
12014  }
12015  }
12016  goto tmp2_end;
12017  tmp2_end: ;
12018  }
12019  goto goto_1;
12020  goto_1:;
12021  MMC_THROW_INTERNAL();
12022  goto tmp2_done;
12023  tmp2_done:;
12024  }
12025  }
12026  _outPath = tmpMeta[0];
12027  _return: OMC_LABEL_UNUSED
12028  return _outPath;
12029 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_FULLYQUALIFIED__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
DLLExport modelica_metatype omc_Absyn_crefToPathIgnoreSubs(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:11953
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_directionEqual()

DLLExport modelica_boolean omc_Absyn_directionEqual ( threadData_t threadData,
modelica_metatype  _inDirection1,
modelica_metatype  _inDirection2 
)

Definition at line 6127 of file Absyn.c.

6128 {
6129  modelica_boolean _outEqual;
6130  modelica_boolean tmp1 = 0;
6131  MMC_SO();
6132  _tailrecursive: OMC_LABEL_UNUSED
6133 #line 6133 OMC_FILE
6134  { /* match expression */
6135  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
6136  tmp4_1 = _inDirection1;
6137  tmp4_2 = _inDirection2;
6138  {
6139  volatile mmc_switch_type tmp4;
6140  int tmp5;
6141  tmp4 = 0;
6142  for (; tmp4 < 5; tmp4++) {
6143  switch (MMC_SWITCH_CAST(tmp4)) {
6144  case 0: {
6145  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,0) == 0) goto tmp3_end;
6146  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,0) == 0) goto tmp3_end;
6147  /* Pattern matching succeeded */
6148 #line 5451 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6149  tmp1 = 1;
6150 #line 6150 OMC_FILE
6151  goto tmp3_done;
6152  }
6153  case 1: {
6154  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
6155  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
6156  /* Pattern matching succeeded */
6157 #line 5452 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6158  tmp1 = 1;
6159 #line 6159 OMC_FILE
6160  goto tmp3_done;
6161  }
6162  case 2: {
6163  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
6164  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
6165  /* Pattern matching succeeded */
6166 #line 5453 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6167  tmp1 = 1;
6168 #line 6168 OMC_FILE
6169  goto tmp3_done;
6170  }
6171  case 3: {
6172  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
6173  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,3,0) == 0) goto tmp3_end;
6174  /* Pattern matching succeeded */
6175 #line 5454 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6176  tmp1 = 1;
6177 #line 6177 OMC_FILE
6178  goto tmp3_done;
6179  }
6180  case 4: {
6181 
6182  /* Pattern matching succeeded */
6183 #line 5455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6184  tmp1 = 0;
6185 #line 6185 OMC_FILE
6186  goto tmp3_done;
6187  }
6188  }
6189  goto tmp3_end;
6190  tmp3_end: ;
6191  }
6192  goto goto_2;
6193  goto_2:;
6194  MMC_THROW_INTERNAL();
6195  goto tmp3_done;
6196  tmp3_done:;
6197  }
6198  }
6199  _outEqual = tmp1;
6200  _return: OMC_LABEL_UNUSED
6201  return _outEqual;
6202 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_dummyTraverseExp()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_dummyTraverseExp ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 3318 of file Absyn.c.

3319 {
3320  modelica_metatype _outExp = NULL;
3321  modelica_metatype _outArg = NULL;
3322  MMC_SO();
3323  _tailrecursive: OMC_LABEL_UNUSED
3324 #line 6200 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3325  _outExp = _inExp;
3326 #line 3326 OMC_FILE
3327 
3328 #line 6201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3329  _outArg = _inArg;
3330 #line 3330 OMC_FILE
3331  _return: OMC_LABEL_UNUSED
3332  if (out_outArg) { *out_outArg = _outArg; }
3333  return _outExp;
3334 }
void * modelica_metatype

◆ omc_Absyn_eachEqual()

DLLExport modelica_boolean omc_Absyn_eachEqual ( threadData_t threadData,
modelica_metatype  _each1,
modelica_metatype  _each2 
)

Definition at line 9422 of file Absyn.c.

9423 {
9424  modelica_boolean _equal;
9425  modelica_boolean tmp1 = 0;
9426  MMC_SO();
9427  _tailrecursive: OMC_LABEL_UNUSED
9428 #line 9428 OMC_FILE
9429  { /* match expression */
9430  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
9431  tmp4_1 = _each1;
9432  tmp4_2 = _each2;
9433  {
9434  volatile mmc_switch_type tmp4;
9435  int tmp5;
9436  tmp4 = 0;
9437  for (; tmp4 < 3; tmp4++) {
9438  switch (MMC_SWITCH_CAST(tmp4)) {
9439  case 0: {
9440  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
9441  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
9442  /* Pattern matching succeeded */
9443 #line 4654 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9444  tmp1 = 1;
9445 #line 9445 OMC_FILE
9446  goto tmp3_done;
9447  }
9448  case 1: {
9449  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
9450  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
9451  /* Pattern matching succeeded */
9452 #line 4655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9453  tmp1 = 1;
9454 #line 9454 OMC_FILE
9455  goto tmp3_done;
9456  }
9457  case 2: {
9458 
9459  /* Pattern matching succeeded */
9460 #line 4656 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9461  tmp1 = 0;
9462 #line 9462 OMC_FILE
9463  goto tmp3_done;
9464  }
9465  }
9466  goto tmp3_end;
9467  tmp3_end: ;
9468  }
9469  goto goto_2;
9470  goto_2:;
9471  MMC_THROW_INTERNAL();
9472  goto tmp3_done;
9473  tmp3_done:;
9474  }
9475  }
9476  _equal = tmp1;
9477  _return: OMC_LABEL_UNUSED
9478  return _equal;
9479 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_elementArgEqualName()

DLLExport modelica_boolean omc_Absyn_elementArgEqualName ( threadData_t threadData,
modelica_metatype  _inArg1,
modelica_metatype  _inArg2 
)

Definition at line 2135 of file Absyn.c.

2136 {
2137  modelica_boolean _outEqual;
2138  modelica_metatype _name1 = NULL;
2139  modelica_metatype _name2 = NULL;
2140  modelica_boolean tmp1 = 0;
2141  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
2142  MMC_SO();
2143  _tailrecursive: OMC_LABEL_UNUSED
2144 #line 2144 OMC_FILE
2145  { /* match expression */
2146  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
2147  tmp4_1 = _inArg1;
2148  tmp4_2 = _inArg2;
2149  {
2150  volatile mmc_switch_type tmp4;
2151  int tmp5;
2152  tmp4 = 0;
2153  for (; tmp4 < 2; tmp4++) {
2154  switch (MMC_SWITCH_CAST(tmp4)) {
2155  case 0: {
2156  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
2157  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
2158  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,6) == 0) goto tmp3_end;
2159  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 4));
2160 
2161  _name1 = tmpMeta[0];
2162  _name2 = tmpMeta[1];
2163  /* Pattern matching succeeded */
2164 #line 6551 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2165  tmp1 = omc_Absyn_pathEqual(threadData, _name1, _name2);
2166 #line 2166 OMC_FILE
2167  goto tmp3_done;
2168  }
2169  case 1: {
2170 
2171  /* Pattern matching succeeded */
2172 #line 6553 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2173  tmp1 = 0;
2174 #line 2174 OMC_FILE
2175  goto tmp3_done;
2176  }
2177  }
2178  goto tmp3_end;
2179  tmp3_end: ;
2180  }
2181  goto goto_2;
2182  goto_2:;
2183  MMC_THROW_INTERNAL();
2184  goto tmp3_done;
2185  tmp3_done:;
2186  }
2187  }
2188  _outEqual = tmp1;
2189  _return: OMC_LABEL_UNUSED
2190  return _outEqual;
2191 }
DLLExport modelica_boolean omc_Absyn_pathEqual(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:17616
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_elementArgName()

DLLExport modelica_metatype omc_Absyn_elementArgName ( threadData_t threadData,
modelica_metatype  _inArg 
)

Definition at line 2202 of file Absyn.c.

2203 {
2204  modelica_metatype _outName = NULL;
2205  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
2206  MMC_SO();
2207  _tailrecursive: OMC_LABEL_UNUSED
2208 #line 2208 OMC_FILE
2209  { /* match expression */
2210  modelica_metatype tmp3_1;
2211  tmp3_1 = _inArg;
2212  {
2213  modelica_metatype _e = NULL;
2214  volatile mmc_switch_type tmp3;
2215  int tmp4;
2216  tmp3 = 0;
2217  for (; tmp3 < 2; tmp3++) {
2218  switch (MMC_SWITCH_CAST(tmp3)) {
2219  case 0: {
2220  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,6) == 0) goto tmp2_end;
2221  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
2222 
2223  _outName = tmpMeta[1];
2224  /* Pattern matching succeeded */
2225 #line 6537 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2226  tmpMeta[0] = _outName;
2227 #line 2227 OMC_FILE
2228  goto tmp2_done;
2229  }
2230  case 1: {
2231  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,6) == 0) goto tmp2_end;
2232  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
2233 
2234  _e = tmpMeta[1];
2235  /* Pattern matching succeeded */
2236 #line 6538 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2237  tmpMeta[0] = omc_Absyn_makeIdentPathFromString(threadData, omc_Absyn_elementSpecName(threadData, _e));
2238 #line 2238 OMC_FILE
2239  goto tmp2_done;
2240  }
2241  }
2242  goto tmp2_end;
2243  tmp2_end: ;
2244  }
2245  goto goto_1;
2246  goto_1:;
2247  MMC_THROW_INTERNAL();
2248  goto tmp2_done;
2249  tmp2_done:;
2250  }
2251  }
2252  _outName = tmpMeta[0];
2253  _return: OMC_LABEL_UNUSED
2254  return _outName;
2255 }
float mmc_switch_type
DLLExport modelica_string omc_Absyn_elementSpecName(threadData_t *threadData, modelica_metatype _inElementSpec)
Definition: Absyn.c:18064
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_makeIdentPathFromString(threadData_t *threadData, modelica_string _s)
Definition: Absyn.c:18229
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_elementSpecName()

DLLExport modelica_string omc_Absyn_elementSpecName ( threadData_t threadData,
modelica_metatype  _inElementSpec 
)

Definition at line 18064 of file Absyn.c.

18065 {
18066  modelica_string _outIdent = NULL;
18067  modelica_string tmp1 = 0;
18068  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
18069  MMC_SO();
18070  _tailrecursive: OMC_LABEL_UNUSED
18071 #line 18071 OMC_FILE
18072  { /* match expression */
18073  modelica_metatype tmp4_1;
18074  tmp4_1 = _inElementSpec;
18075  {
18076  modelica_string _n = NULL;
18077  volatile mmc_switch_type tmp4;
18078  int tmp5;
18079  tmp4 = 0;
18080  for (; tmp4 < 2; tmp4++) {
18081  switch (MMC_SWITCH_CAST(tmp4)) {
18082  case 0: {
18083  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
18084  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18085  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
18086 
18087  _n = tmpMeta[1];
18088  /* Pattern matching succeeded */
18089 #line 2455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18090  tmp1 = _n;
18091 #line 18091 OMC_FILE
18092  goto tmp3_done;
18093  }
18094  case 1: {
18095  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,3) == 0) goto tmp3_end;
18096  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
18097  if (listEmpty(tmpMeta[0])) goto tmp3_end;
18098  tmpMeta[1] = MMC_CAR(tmpMeta[0]);
18099  tmpMeta[2] = MMC_CDR(tmpMeta[0]);
18100  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
18101  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
18102  if (!listEmpty(tmpMeta[2])) goto tmp3_end;
18103  _n = tmpMeta[4];
18104  /* Pattern matching succeeded */
18105 #line 2456 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18106  tmp1 = _n;
18107 #line 18107 OMC_FILE
18108  goto tmp3_done;
18109  }
18110  }
18111  goto tmp3_end;
18112  tmp3_end: ;
18113  }
18114  goto goto_2;
18115  goto_2:;
18116  MMC_THROW_INTERNAL();
18117  goto tmp3_done;
18118  tmp3_done:;
18119  }
18120  }
18121  _outIdent = tmp1;
18122  _return: OMC_LABEL_UNUSED
18123  return _outIdent;
18124 }
modelica_metatype modelica_string
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_elementSpecToPath()

DLLExport modelica_metatype omc_Absyn_elementSpecToPath ( threadData_t threadData,
modelica_metatype  _inElementSpec 
)

Definition at line 12032 of file Absyn.c.

12033 {
12034  modelica_metatype _outPath = NULL;
12035  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
12036  MMC_SO();
12037  _tailrecursive: OMC_LABEL_UNUSED
12038 #line 12038 OMC_FILE
12039  { /* match expression */
12040  modelica_metatype tmp3_1;
12041  tmp3_1 = _inElementSpec;
12042  {
12043  modelica_metatype _p = NULL;
12044  volatile mmc_switch_type tmp3;
12045  int tmp4;
12046  tmp3 = 0;
12047  for (; tmp3 < 1; tmp3++) {
12048  switch (MMC_SWITCH_CAST(tmp3)) {
12049  case 0: {
12050  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
12051  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12052 
12053  _p = tmpMeta[1];
12054  /* Pattern matching succeeded */
12055 #line 4026 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12056  tmpMeta[0] = _p;
12057 #line 12057 OMC_FILE
12058  goto tmp2_done;
12059  }
12060  }
12061  goto tmp2_end;
12062  tmp2_end: ;
12063  }
12064  goto goto_1;
12065  goto_1:;
12066  MMC_THROW_INTERNAL();
12067  goto tmp2_done;
12068  tmp2_done:;
12069  }
12070  }
12071  _outPath = tmpMeta[0];
12072  _return: OMC_LABEL_UNUSED
12073  return _outPath;
12074 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_expComponentRefStr()

DLLExport modelica_string omc_Absyn_expComponentRefStr ( threadData_t threadData,
modelica_metatype  _aexp 
)

Definition at line 17865 of file Absyn.c.

17866 {
17867  modelica_string _outString = NULL;
17868  MMC_SO();
17869  _tailrecursive: OMC_LABEL_UNUSED
17870 #line 2519 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17871  _outString = omc_Absyn_printComponentRefStr(threadData, omc_Absyn_expCref(threadData, _aexp));
17872 #line 17872 OMC_FILE
17873  _return: OMC_LABEL_UNUSED
17874  return _outString;
17875 }
DLLExport modelica_string omc_Absyn_printComponentRefStr(threadData_t *threadData, modelica_metatype _cr)
Definition: Absyn.c:17769
modelica_metatype modelica_string
DLLExport modelica_metatype omc_Absyn_expCref(threadData_t *threadData, modelica_metatype _exp)
Definition: Absyn.c:17894
Here is the call graph for this function:

◆ omc_Absyn_expContainsInitial()

DLLExport modelica_boolean omc_Absyn_expContainsInitial ( threadData_t threadData,
modelica_metatype  _inExp 
)

Definition at line 5204 of file Absyn.c.

5205 {
5206  modelica_boolean _hasInitial;
5207  modelica_boolean tmp1 = 0;
5208  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
5209  MMC_SO();
5210  _tailrecursive: OMC_LABEL_UNUSED
5211 #line 5211 OMC_FILE
5212  { /* matchcontinue expression */
5213  {
5214  modelica_boolean _b;
5215  volatile mmc_switch_type tmp4;
5216  int tmp5;
5217  tmp4 = 0;
5218  MMC_TRY_INTERNAL(mmc_jumper)
5219  tmp3_top:
5220  threadData->mmc_jumper = &new_mmc_jumper;
5221  for (; tmp4 < 2; tmp4++) {
5222  switch (MMC_SWITCH_CAST(tmp4)) {
5223  case 0: {
5224  modelica_integer tmp6;
5225  /* Pattern matching succeeded */
5226 #line 5674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5227  /* Pattern-matching tuple assignment, wild first pattern */
5228 #line 5674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5229  omc_Absyn_traverseExp(threadData, _inExp, boxvar_Absyn_isInitialTraverseHelper, mmc_mk_boolean(0), &tmpMeta[0]);
5230 #line 5674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5231  tmp6 = mmc_unbox_integer(tmpMeta[0]);
5232 #line 5674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5233  _b = tmp6 /* pattern as ty=Boolean */;
5234 #line 5234 OMC_FILE
5235 #line 5675 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5236  tmp1 = _b;
5237 #line 5237 OMC_FILE
5238  goto tmp3_done;
5239  }
5240  case 1: {
5241  /* Pattern matching succeeded */
5242 #line 5677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5243  tmp1 = 0;
5244 #line 5244 OMC_FILE
5245  goto tmp3_done;
5246  }
5247  }
5248  goto tmp3_end;
5249  tmp3_end: ;
5250  }
5251  goto goto_2;
5252  tmp3_done:
5253  (void)tmp4;
5254  MMC_RESTORE_INTERNAL(mmc_jumper);
5255  goto tmp3_done2;
5256  goto_2:;
5257  MMC_CATCH_INTERNAL(mmc_jumper);
5258  if (++tmp4 < 2) {
5259  goto tmp3_top;
5260  }
5261  MMC_THROW_INTERNAL();
5262  tmp3_done2:;
5263  }
5264  }
5265  _hasInitial = tmp1;
5266  _return: OMC_LABEL_UNUSED
5267  return _hasInitial;
5268 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
m_integer modelica_integer
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_traverseExp(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:20906
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_expCref()

DLLExport modelica_metatype omc_Absyn_expCref ( threadData_t threadData,
modelica_metatype  _exp 
)

Definition at line 17894 of file Absyn.c.

17895 {
17896  modelica_metatype _cr = NULL;
17897  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
17898  MMC_SO();
17899  _tailrecursive: OMC_LABEL_UNUSED
17900 #line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17901  /* Pattern-matching assignment */
17902 #line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17903  tmpMeta[0] = _exp;
17904 #line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17905  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],2,1) == 0) MMC_THROW_INTERNAL();
17906 #line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17907  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
17908 #line 2504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17909  _cr = tmpMeta[1];
17910 #line 17910 OMC_FILE
17911  _return: OMC_LABEL_UNUSED
17912  return _cr;
17913 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_expEqual()

DLLExport modelica_boolean omc_Absyn_expEqual ( threadData_t threadData,
modelica_metatype  _exp1,
modelica_metatype  _exp2 
)

Definition at line 9490 of file Absyn.c.

9491 {
9492  modelica_boolean _equal;
9493  modelica_boolean tmp1 = 0;
9494  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
9495  MMC_SO();
9496  _tailrecursive: OMC_LABEL_UNUSED
9497 #line 9497 OMC_FILE
9498  { /* matchcontinue expression */
9499  volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
9500  tmp4_1 = _exp1;
9501  tmp4_2 = _exp2;
9502  {
9503  modelica_metatype _x = NULL;
9504  modelica_metatype _y = NULL;
9505  modelica_integer _i;
9506  modelica_string _r = NULL;
9507  volatile mmc_switch_type tmp4;
9508  int tmp5;
9509  tmp4 = 0;
9510  MMC_TRY_INTERNAL(mmc_jumper)
9511  tmp3_top:
9512  threadData->mmc_jumper = &new_mmc_jumper;
9513  for (; tmp4 < 3; tmp4++) {
9514  switch (MMC_SWITCH_CAST(tmp4)) {
9515  case 0: {
9516  modelica_integer tmp6;
9517  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
9518  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
9519  tmp6 = mmc_unbox_integer(tmpMeta[0]);
9520  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
9521  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
9522  _i = tmp6 /* pattern as ty=Integer */;
9523  _r = tmpMeta[1];
9524  tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
9525 #line 4635 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9526  tmp1 = (((modelica_real)((modelica_integer)_i)) == stringReal(_r));
9527 #line 9527 OMC_FILE
9528  goto tmp3_done;
9529  }
9530  case 1: {
9531  modelica_integer tmp7;
9532  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
9533  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
9534  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,1) == 0) goto tmp3_end;
9535  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
9536  tmp7 = mmc_unbox_integer(tmpMeta[1]);
9537  _r = tmpMeta[0];
9538  _i = tmp7 /* pattern as ty=Integer */;
9539  /* Pattern matching succeeded */
9540 #line 4640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9541  tmp1 = (((modelica_real)((modelica_integer)_i)) == stringReal(_r));
9542 #line 9542 OMC_FILE
9543  goto tmp3_done;
9544  }
9545  case 2: {
9546 
9547  _x = tmp4_1;
9548  _y = tmp4_2;
9549  /* Pattern matching succeeded */
9550 #line 4644 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9551  tmp1 = valueEq(_x, _y);
9552 #line 9552 OMC_FILE
9553  goto tmp3_done;
9554  }
9555  }
9556  goto tmp3_end;
9557  tmp3_end: ;
9558  }
9559  goto goto_2;
9560  tmp3_done:
9561  (void)tmp4;
9562  MMC_RESTORE_INTERNAL(mmc_jumper);
9563  goto tmp3_done2;
9564  goto_2:;
9565  MMC_CATCH_INTERNAL(mmc_jumper);
9566  if (++tmp4 < 3) {
9567  goto tmp3_top;
9568  }
9569  MMC_THROW_INTERNAL();
9570  tmp3_done2:;
9571  }
9572  }
9573  _equal = tmp1;
9574  _return: OMC_LABEL_UNUSED
9575  return _equal;
9576 }
double modelica_real
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
m_integer modelica_integer
signed char modelica_boolean
float mmc_switch_type
modelica_boolean valueEq(modelica_metatype lhs, modelica_metatype rhs)
Definition: meta_modelica.c:99
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_expString()

DLLExport modelica_string omc_Absyn_expString ( threadData_t threadData,
modelica_metatype  _exp 
)

Definition at line 17916 of file Absyn.c.

17917 {
17918  modelica_string _str = NULL;
17919  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
17920  MMC_SO();
17921  _tailrecursive: OMC_LABEL_UNUSED
17922 #line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17923  /* Pattern-matching assignment */
17924 #line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17925  tmpMeta[0] = _exp;
17926 #line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17927  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],3,1) == 0) MMC_THROW_INTERNAL();
17928 #line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17929  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
17930 #line 2497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17931  _str = tmpMeta[1];
17932 #line 17932 OMC_FILE
17933  _return: OMC_LABEL_UNUSED
17934  return _str;
17935 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_filterAnnotationItem()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_filterAnnotationItem ( threadData_t threadData,
modelica_metatype  _elt 
)

Definition at line 5557 of file Absyn.c.

5558 {
5559  modelica_boolean _outB;
5560  modelica_boolean tmp1 = 0;
5561  MMC_SO();
5562  _tailrecursive: OMC_LABEL_UNUSED
5563 #line 5563 OMC_FILE
5564  { /* match expression */
5565  modelica_metatype tmp4_1;
5566  tmp4_1 = _elt;
5567  {
5568  volatile mmc_switch_type tmp4;
5569  int tmp5;
5570  tmp4 = 0;
5571  for (; tmp4 < 2; tmp4++) {
5572  switch (MMC_SWITCH_CAST(tmp4)) {
5573  case 0: {
5574  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
5575 
5576  /* Pattern matching succeeded */
5577 #line 5580 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5578  tmp1 = 1;
5579 #line 5579 OMC_FILE
5580  goto tmp3_done;
5581  }
5582  case 1: {
5583 
5584  /* Pattern matching succeeded */
5585 #line 5581 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5586  tmp1 = 0;
5587 #line 5587 OMC_FILE
5588  goto tmp3_done;
5589  }
5590  }
5591  goto tmp3_end;
5592  tmp3_end: ;
5593  }
5594  goto goto_2;
5595  goto_2:;
5596  MMC_THROW_INTERNAL();
5597  goto tmp3_done;
5598  tmp3_done:;
5599  }
5600  }
5601  _outB = tmp1;
5602  _return: OMC_LABEL_UNUSED
5603  return _outB;
5604 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_findIteratorIndexedCrefs()

DLLExport modelica_metatype omc_Absyn_findIteratorIndexedCrefs ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_string  _inIterator,
modelica_metatype  _inCrefs 
)

Definition at line 9312 of file Absyn.c.

9313 {
9314  modelica_metatype _outCrefs = NULL;
9315  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
9316  MMC_SO();
9317  _tailrecursive: OMC_LABEL_UNUSED
9318 #line 4695 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9319  tmpMeta[0] = mmc_mk_box1(0, _inIterator);
9320 #line 4695 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9321  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
9322 #line 4695 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9323  omc_Absyn_traverseExp(threadData, _inExp, (modelica_fnptr) mmc_mk_box2(0,closure6_Absyn_findIteratorIndexedCrefs__traverser,tmpMeta[0]), tmpMeta[1] ,&_outCrefs);
9324 #line 9324 OMC_FILE
9325 
9326 #line 4697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9327  tmpMeta[0] = mmc_mk_box1(0, boxvar_Absyn_iteratorIndexedCrefsEqual);
9328 #line 4697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9329  _outCrefs = omc_List_fold(threadData, _outCrefs, (modelica_fnptr) mmc_mk_box2(0,closure7_List_unionEltOnTrue,tmpMeta[0]), _inCrefs);
9330 #line 9330 OMC_FILE
9331  _return: OMC_LABEL_UNUSED
9332  return _outCrefs;
9333 }
void * modelica_fnptr
DLLExport modelica_metatype omc_Absyn_traverseExp(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:20906
void * modelica_metatype
DLLExport modelica_metatype omc_List_fold(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFoldFunc, modelica_metatype _inStartValue)
Definition: List.c:9662
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_findIteratorIndexedCrefs__traverser()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_findIteratorIndexedCrefs__traverser ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_metatype  _inCrefs,
modelica_string  _inIterator,
modelica_metatype out_outCrefs 
)

Definition at line 9248 of file Absyn.c.

9249 {
9250  modelica_metatype _outExp = NULL;
9251  modelica_metatype _outCrefs = NULL;
9252  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
9253  MMC_SO();
9254  _tailrecursive: OMC_LABEL_UNUSED
9255  _outExp = _inExp;
9256 #line 9256 OMC_FILE
9257  { /* match expression */
9258  modelica_metatype tmp3_1;
9259  tmp3_1 = _inExp;
9260  {
9261  modelica_metatype _cref = NULL;
9262  volatile mmc_switch_type tmp3;
9263  int tmp4;
9264  tmp3 = 0;
9265  for (; tmp3 < 2; tmp3++) {
9266  switch (MMC_SWITCH_CAST(tmp3)) {
9267  case 0: {
9268  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
9269  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
9270  _cref = tmpMeta[1];
9271  /* Pattern matching succeeded */
9272 #line 4715 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9273  tmpMeta[0] = omc_Absyn_getIteratorIndexedCrefs(threadData, _cref, _inIterator, _inCrefs);
9274 #line 9274 OMC_FILE
9275  goto tmp2_done;
9276  }
9277  case 1: {
9278 
9279  /* Pattern matching succeeded */
9280 #line 4717 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9281  tmpMeta[0] = _inCrefs;
9282 #line 9282 OMC_FILE
9283  goto tmp2_done;
9284  }
9285  }
9286  goto tmp2_end;
9287  tmp2_end: ;
9288  }
9289  goto goto_1;
9290  goto_1:;
9291  MMC_THROW_INTERNAL();
9292  goto tmp2_done;
9293  tmp2_done:;
9294  }
9295  }
9296  _outCrefs = tmpMeta[0];
9297  _return: OMC_LABEL_UNUSED
9298  if (out_outCrefs) { *out_outCrefs = _outCrefs; }
9299  return _outExp;
9300 }
float mmc_switch_type
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getIteratorIndexedCrefs(threadData_t *threadData, modelica_metatype _inCref, modelica_string _inIterator, modelica_metatype _inCrefs)
Definition: Absyn.c:8931
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_functionArgsEqual()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_functionArgsEqual ( threadData_t threadData,
modelica_metatype  _args1,
modelica_metatype  _args2 
)

Definition at line 9355 of file Absyn.c.

9356 {
9357  modelica_boolean _equal;
9358  modelica_boolean tmp1 = 0;
9359  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
9360  MMC_SO();
9361  _tailrecursive: OMC_LABEL_UNUSED
9362 #line 9362 OMC_FILE
9363  { /* match expression */
9364  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
9365  tmp4_1 = _args1;
9366  tmp4_2 = _args2;
9367  {
9368  modelica_metatype _expl1 = NULL;
9369  modelica_metatype _expl2 = NULL;
9370  volatile mmc_switch_type tmp4;
9371  int tmp5;
9372  tmp4 = 0;
9373  for (; tmp4 < 2; tmp4++) {
9374  switch (MMC_SWITCH_CAST(tmp4)) {
9375  case 0: {
9376  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
9377  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
9378  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
9379  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
9380 
9381  _expl1 = tmpMeta[0];
9382  _expl2 = tmpMeta[1];
9383  /* Pattern matching succeeded */
9384 #line 4670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9385  tmp1 = omc_List_isEqualOnTrue(threadData, _expl1, _expl2, boxvar_Absyn_expEqual);
9386 #line 9386 OMC_FILE
9387  goto tmp3_done;
9388  }
9389  case 1: {
9390 
9391  /* Pattern matching succeeded */
9392 #line 4672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9393  tmp1 = 0;
9394 #line 9394 OMC_FILE
9395  goto tmp3_done;
9396  }
9397  }
9398  goto tmp3_end;
9399  tmp3_end: ;
9400  }
9401  goto goto_2;
9402  goto_2:;
9403  MMC_THROW_INTERNAL();
9404  goto tmp3_done;
9405  tmp3_done:;
9406  }
9407  }
9408  _equal = tmp1;
9409  _return: OMC_LABEL_UNUSED
9410  return _equal;
9411 }
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_List_isEqualOnTrue(threadData_t *threadData, modelica_metatype _inList1, modelica_metatype _inList2, modelica_fnptr _inCompFunc)
Definition: List.c:18331
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getArrayDimOptAsList()

DLLExport modelica_metatype omc_Absyn_getArrayDimOptAsList ( threadData_t threadData,
modelica_metatype  _inArrayDim 
)

Definition at line 4066 of file Absyn.c.

4067 {
4068  modelica_metatype _outArrayDim = NULL;
4069  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
4070  MMC_SO();
4071  _tailrecursive: OMC_LABEL_UNUSED
4072 #line 4072 OMC_FILE
4073  { /* match expression */
4074  modelica_metatype tmp3_1;
4075  tmp3_1 = _inArrayDim;
4076  {
4077  modelica_metatype _ad = NULL;
4078  volatile mmc_switch_type tmp3;
4079  int tmp4;
4080  tmp3 = 0;
4081  for (; tmp3 < 2; tmp3++) {
4082  switch (MMC_SWITCH_CAST(tmp3)) {
4083  case 0: {
4084  if (optionNone(tmp3_1)) goto tmp2_end;
4085  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
4086  _ad = tmpMeta[1];
4087  /* Pattern matching succeeded */
4088 #line 5990 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4089  tmpMeta[0] = _ad;
4090 #line 4090 OMC_FILE
4091  goto tmp2_done;
4092  }
4093  case 1: {
4094 
4095  /* Pattern matching succeeded */
4096 #line 5991 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4097  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
4098 #line 5991 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4099  tmpMeta[0] = tmpMeta[1];
4100 #line 4100 OMC_FILE
4101  goto tmp2_done;
4102  }
4103  }
4104  goto tmp2_end;
4105  tmp2_end: ;
4106  }
4107  goto goto_1;
4108  goto_1:;
4109  MMC_THROW_INTERNAL();
4110  goto tmp2_done;
4111  tmp2_done:;
4112  }
4113  }
4114  _outArrayDim = tmpMeta[0];
4115  _return: OMC_LABEL_UNUSED
4116  return _outArrayDim;
4117 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_getClassName()

DLLExport modelica_string omc_Absyn_getClassName ( threadData_t threadData,
modelica_metatype  _inClass 
)

Definition at line 9336 of file Absyn.c.

9337 {
9338  modelica_string _outName = NULL;
9339  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
9340  MMC_SO();
9341  _tailrecursive: OMC_LABEL_UNUSED
9342 #line 4681 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9343  /* Pattern-matching assignment */
9344 #line 4681 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9345  tmpMeta[0] = _inClass;
9346 #line 4681 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9347  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
9348 #line 4681 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9349  _outName = tmpMeta[1];
9350 #line 9350 OMC_FILE
9351  _return: OMC_LABEL_UNUSED
9352  return _outName;
9353 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_getCrefFromExp()

DLLExport modelica_metatype omc_Absyn_getCrefFromExp ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_boolean  _includeSubs,
modelica_boolean  _includeFunctions 
)

Definition at line 13198 of file Absyn.c.

13199 {
13200  modelica_metatype _outComponentRefLst = NULL;
13201  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
13202  MMC_SO();
13203  _tailrecursive: OMC_LABEL_UNUSED
13204 #line 13204 OMC_FILE
13205  { /* match expression */
13206  modelica_metatype tmp3_1;modelica_boolean tmp3_2;
13207  tmp3_1 = _inExp;
13208  tmp3_2 = _includeSubs;
13209  {
13210  modelica_metatype _cr = NULL;
13211  modelica_metatype _l1 = NULL;
13212  modelica_metatype _l2 = NULL;
13213  modelica_metatype _res = NULL;
13214  modelica_metatype _e1 = NULL;
13215  modelica_metatype _e2 = NULL;
13216  modelica_metatype _e3 = NULL;
13217  modelica_metatype _farg = NULL;
13218  modelica_metatype _expl = NULL;
13219  modelica_metatype _expll = NULL;
13220  modelica_metatype _subs = NULL;
13221  modelica_metatype _lstres1 = NULL;
13222  modelica_metatype _crefll = NULL;
13223  volatile mmc_switch_type tmp3;
13224  int tmp4;
13225  tmp3 = 0;
13226  for (; tmp3 < 29; tmp3++) {
13227  switch (MMC_SWITCH_CAST(tmp3)) {
13228  case 0: {
13229  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
13230 
13231  /* Pattern matching succeeded */
13232 #line 3553 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13233  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13234 #line 3553 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13235  tmpMeta[0] = tmpMeta[1];
13236 #line 13236 OMC_FILE
13237  goto tmp2_done;
13238  }
13239  case 1: {
13240  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
13241 
13242  /* Pattern matching succeeded */
13243 #line 3554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13244  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13245 #line 3554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13246  tmpMeta[0] = tmpMeta[1];
13247 #line 13247 OMC_FILE
13248  goto tmp2_done;
13249  }
13250  case 2: {
13251  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,3,1) == 0) goto tmp2_end;
13252 
13253  /* Pattern matching succeeded */
13254 #line 3555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13255  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13256 #line 3555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13257  tmpMeta[0] = tmpMeta[1];
13258 #line 13258 OMC_FILE
13259  goto tmp2_done;
13260  }
13261  case 3: {
13262  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,4,1) == 0) goto tmp2_end;
13263 
13264  /* Pattern matching succeeded */
13265 #line 3556 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13266  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13267 #line 3556 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13268  tmpMeta[0] = tmpMeta[1];
13269 #line 13269 OMC_FILE
13270  goto tmp2_done;
13271  }
13272  case 4: {
13273  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
13274  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13275  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],4,0) == 0) goto tmp2_end;
13276 
13277  /* Pattern matching succeeded */
13278 #line 3557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13279  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13280 #line 3557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13281  tmpMeta[0] = tmpMeta[1];
13282 #line 13282 OMC_FILE
13283  goto tmp2_done;
13284  }
13285  case 5: {
13286  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
13287  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13288  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],3,0) == 0) goto tmp2_end;
13289 
13290  /* Pattern matching succeeded */
13291 #line 3558 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13292  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13293 #line 3558 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13294  tmpMeta[0] = tmpMeta[1];
13295 #line 13295 OMC_FILE
13296  goto tmp2_done;
13297  }
13298  case 6: {
13299  if (0 != tmp3_2) goto tmp2_end;
13300  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
13301  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13302  _cr = tmpMeta[1];
13303  /* Pattern matching succeeded */
13304 #line 3559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13305  tmpMeta[1] = mmc_mk_cons(_cr, MMC_REFSTRUCTLIT(mmc_nil));
13306 #line 3559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13307  tmpMeta[0] = tmpMeta[1];
13308 #line 13308 OMC_FILE
13309  goto tmp2_done;
13310  }
13311  case 7: {
13312  if (1 != tmp3_2) goto tmp2_end;
13313  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
13314  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13315  _cr = tmpMeta[1];
13316  /* Pattern matching succeeded */
13317 #line 3563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13318  _subs = omc_Absyn_getSubsFromCref(threadData, _cr, _includeSubs, _includeFunctions);
13319 #line 13319 OMC_FILE
13320 
13321 #line 3564 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13322  _l1 = omc_Absyn_getCrefsFromSubs(threadData, _subs, _includeSubs, _includeFunctions);
13323 #line 13323 OMC_FILE
13324 #line 3565 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13325  tmpMeta[1] = mmc_mk_cons(_cr, _l1);
13326 #line 3565 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13327  tmpMeta[0] = tmpMeta[1];
13328 #line 13328 OMC_FILE
13329  goto tmp2_done;
13330  }
13331  case 8: {
13332  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,5,3) == 0) goto tmp2_end;
13333  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13334  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
13335 
13336  _e1 = tmpMeta[1];
13337  _e2 = tmpMeta[2];
13338  /* Pattern matching succeeded */
13339 #line 3569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13340  _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
13341 #line 13341 OMC_FILE
13342 
13343 #line 3570 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13344  _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
13345 #line 13345 OMC_FILE
13346 #line 3571 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13347  tmpMeta[0] = listAppend(_l1, _l2);
13348 #line 13348 OMC_FILE
13349  goto tmp2_done;
13350  }
13351  case 9: {
13352  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,6,2) == 0) goto tmp2_end;
13353  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13354 
13355  _e1 = tmpMeta[1];
13356  /* Pattern matching succeeded */
13357 #line 3577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13358  /* Tail recursive call */
13359 #line 3577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13360  _inExp = _e1;
13361 #line 3577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13362  goto _tailrecursive;
13363 #line 3577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13364  /* TODO: Make sure any eventual dead code below is never generated */
13365 #line 13365 OMC_FILE
13366  goto tmp2_done;
13367  }
13368  case 10: {
13369  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,7,3) == 0) goto tmp2_end;
13370  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13371  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
13372 
13373  _e1 = tmpMeta[1];
13374  _e2 = tmpMeta[2];
13375  /* Pattern matching succeeded */
13376 #line 3583 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13377  _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
13378 #line 13378 OMC_FILE
13379 
13380 #line 3584 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13381  _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
13382 #line 13382 OMC_FILE
13383 #line 3585 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13384  tmpMeta[0] = listAppend(_l1, _l2);
13385 #line 13385 OMC_FILE
13386  goto tmp2_done;
13387  }
13388  case 11: {
13389  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,8,2) == 0) goto tmp2_end;
13390  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13391 
13392  _e1 = tmpMeta[1];
13393  /* Pattern matching succeeded */
13394 #line 3591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13395  /* Tail recursive call */
13396 #line 3591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13397  _inExp = _e1;
13398 #line 3591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13399  goto _tailrecursive;
13400 #line 3591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13401  /* TODO: Make sure any eventual dead code below is never generated */
13402 #line 13402 OMC_FILE
13403  goto tmp2_done;
13404  }
13405  case 12: {
13406  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,9,3) == 0) goto tmp2_end;
13407  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13408  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
13409 
13410  _e1 = tmpMeta[1];
13411  _e2 = tmpMeta[2];
13412  /* Pattern matching succeeded */
13413 #line 3597 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13414  _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
13415 #line 13415 OMC_FILE
13416 
13417 #line 3598 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13418  _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
13419 #line 13419 OMC_FILE
13420 #line 3599 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13421  tmpMeta[0] = listAppend(_l1, _l2);
13422 #line 13422 OMC_FILE
13423  goto tmp2_done;
13424  }
13425  case 13: {
13426  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,10,4) == 0) goto tmp2_end;
13427  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13428  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13429  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
13430 
13431  _e1 = tmpMeta[1];
13432  _e2 = tmpMeta[2];
13433  _e3 = tmpMeta[3];
13434  /* Pattern matching succeeded */
13435 #line 3605 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13436  tmpMeta[1] = mmc_mk_cons(omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions), mmc_mk_cons(omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions), mmc_mk_cons(omc_Absyn_getCrefFromExp(threadData, _e3, _includeSubs, _includeFunctions), MMC_REFSTRUCTLIT(mmc_nil))));
13437 #line 3605 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13438  tmpMeta[0] = omc_List_flatten(threadData, tmpMeta[1]);
13439 #line 13439 OMC_FILE
13440  goto tmp2_done;
13441  }
13442  case 14: {
13443  modelica_boolean tmp5;
13444  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,11,2) == 0) goto tmp2_end;
13445  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13446  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13447 
13448  _cr = tmpMeta[1];
13449  _farg = tmpMeta[2];
13450  /* Pattern matching succeeded */
13451 #line 3612 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13452  _res = omc_Absyn_getCrefFromFarg(threadData, _farg, _includeSubs, _includeFunctions);
13453 #line 13453 OMC_FILE
13454 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13455  tmp5 = (modelica_boolean)_includeFunctions;
13456 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13457  if(tmp5)
13458 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13459  {
13460 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13461  tmpMeta[1] = mmc_mk_cons(_cr, _res);
13462 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13463  tmpMeta[2] = tmpMeta[1];
13464 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13465  }
13466 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13467  else
13468 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13469  {
13470 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13471  tmpMeta[2] = _res;
13472 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13473  }
13474 #line 3613 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13475  tmpMeta[0] = tmpMeta[2];
13476 #line 13476 OMC_FILE
13477  goto tmp2_done;
13478  }
13479  case 15: {
13480  modelica_boolean tmp6;
13481  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,12,2) == 0) goto tmp2_end;
13482  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13483  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13484 
13485  _cr = tmpMeta[1];
13486  _farg = tmpMeta[2];
13487  /* Pattern matching succeeded */
13488 #line 3618 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13489  _res = omc_Absyn_getCrefFromFarg(threadData, _farg, _includeSubs, _includeFunctions);
13490 #line 13490 OMC_FILE
13491 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13492  tmp6 = (modelica_boolean)_includeFunctions;
13493 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13494  if(tmp6)
13495 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13496  {
13497 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13498  tmpMeta[1] = mmc_mk_cons(_cr, _res);
13499 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13500  tmpMeta[2] = tmpMeta[1];
13501 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13502  }
13503 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13504  else
13505 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13506  {
13507 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13508  tmpMeta[2] = _res;
13509 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13510  }
13511 #line 3619 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13512  tmpMeta[0] = tmpMeta[2];
13513 #line 13513 OMC_FILE
13514  goto tmp2_done;
13515  }
13516  case 16: {
13517  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,13,1) == 0) goto tmp2_end;
13518  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13519 
13520  _expl = tmpMeta[1];
13521  /* Pattern matching succeeded */
13522 #line 3624 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13523  _lstres1 = omc_List_map2(threadData, _expl, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
13524 #line 13524 OMC_FILE
13525 #line 3625 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13526  tmpMeta[0] = omc_List_flatten(threadData, _lstres1);
13527 #line 13527 OMC_FILE
13528  goto tmp2_done;
13529  }
13530  case 17: {
13531  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,14,1) == 0) goto tmp2_end;
13532  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13533 
13534  _expll = tmpMeta[1];
13535  /* Pattern matching succeeded */
13536 #line 3630 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13537  tmpMeta[0] = omc_List_flatten(threadData, omc_List_flatten(threadData, omc_List_map2List(threadData, _expll, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions))));
13538 #line 13538 OMC_FILE
13539  goto tmp2_done;
13540  }
13541  case 18: {
13542  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,15,3) == 0) goto tmp2_end;
13543  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13544  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13545  if (optionNone(tmpMeta[2])) goto tmp2_end;
13546  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
13547  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
13548 
13549  _e1 = tmpMeta[1];
13550  _e3 = tmpMeta[3];
13551  _e2 = tmpMeta[4];
13552  /* Pattern matching succeeded */
13553 #line 3635 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13554  _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
13555 #line 13555 OMC_FILE
13556 
13557 #line 3636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13558  _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
13559 #line 13559 OMC_FILE
13560 
13561 #line 3637 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13562  _l2 = listAppend(_l1, _l2);
13563 #line 13563 OMC_FILE
13564 
13565 #line 3638 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13566  _l1 = omc_Absyn_getCrefFromExp(threadData, _e3, _includeSubs, _includeFunctions);
13567 #line 13567 OMC_FILE
13568 #line 3639 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13569  tmpMeta[0] = listAppend(_l1, _l2);
13570 #line 13570 OMC_FILE
13571  goto tmp2_done;
13572  }
13573  case 19: {
13574  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,15,3) == 0) goto tmp2_end;
13575  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13576  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13577  if (!optionNone(tmpMeta[2])) goto tmp2_end;
13578  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
13579 
13580  _e1 = tmpMeta[1];
13581  _e2 = tmpMeta[3];
13582  /* Pattern matching succeeded */
13583 #line 3644 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13584  _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
13585 #line 13585 OMC_FILE
13586 
13587 #line 3645 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13588  _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
13589 #line 13589 OMC_FILE
13590 #line 3646 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13591  tmpMeta[0] = listAppend(_l1, _l2);
13592 #line 13592 OMC_FILE
13593  goto tmp2_done;
13594  }
13595  case 20: {
13596  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,17,0) == 0) goto tmp2_end;
13597 
13598  /* Pattern matching succeeded */
13599 #line 3650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13600  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13601 #line 3650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13602  tmpMeta[0] = tmpMeta[1];
13603 #line 13603 OMC_FILE
13604  goto tmp2_done;
13605  }
13606  case 21: {
13607  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,16,1) == 0) goto tmp2_end;
13608  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13609 
13610  _expl = tmpMeta[1];
13611  /* Pattern matching succeeded */
13612 #line 3654 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13613  _crefll = omc_List_map2(threadData, _expl, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
13614 #line 13614 OMC_FILE
13615 #line 3655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13616  tmpMeta[0] = omc_List_flatten(threadData, _crefll);
13617 #line 13617 OMC_FILE
13618  goto tmp2_done;
13619  }
13620  case 22: {
13621  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,18,1) == 0) goto tmp2_end;
13622 
13623  /* Pattern matching succeeded */
13624 #line 3659 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13625  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13626 #line 3659 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13627  tmpMeta[0] = tmpMeta[1];
13628 #line 13628 OMC_FILE
13629  goto tmp2_done;
13630  }
13631  case 23: {
13632  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,19,2) == 0) goto tmp2_end;
13633  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13634 
13635  _e1 = tmpMeta[1];
13636  /* Pattern matching succeeded */
13637 #line 3661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13638  /* Tail recursive call */
13639 #line 3661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13640  _inExp = _e1;
13641 #line 3661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13642  goto _tailrecursive;
13643 #line 3661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13644  /* TODO: Make sure any eventual dead code below is never generated */
13645 #line 13645 OMC_FILE
13646  goto tmp2_done;
13647  }
13648  case 24: {
13649  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,20,2) == 0) goto tmp2_end;
13650  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13651  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13652 
13653  _e1 = tmpMeta[1];
13654  _e2 = tmpMeta[2];
13655  /* Pattern matching succeeded */
13656 #line 3665 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13657  _l1 = omc_Absyn_getCrefFromExp(threadData, _e1, _includeSubs, _includeFunctions);
13658 #line 13658 OMC_FILE
13659 
13660 #line 3666 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13661  _l2 = omc_Absyn_getCrefFromExp(threadData, _e2, _includeSubs, _includeFunctions);
13662 #line 13662 OMC_FILE
13663 #line 3667 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13664  tmpMeta[0] = listAppend(_l1, _l2);
13665 #line 13665 OMC_FILE
13666  goto tmp2_done;
13667  }
13668  case 25: {
13669  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,22,1) == 0) goto tmp2_end;
13670  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13671 
13672  _expl = tmpMeta[1];
13673  /* Pattern matching succeeded */
13674 #line 3673 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13675  _crefll = omc_List_map2(threadData, _expl, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
13676 #line 13676 OMC_FILE
13677 #line 3674 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13678  tmpMeta[0] = omc_List_flatten(threadData, _crefll);
13679 #line 13679 OMC_FILE
13680  goto tmp2_done;
13681  }
13682  case 26: {
13683  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,21,5) == 0) goto tmp2_end;
13684 
13685  /* Pattern matching succeeded */
13686 #line 3678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13687  goto goto_1;
13688 #line 13688 OMC_FILE
13689  goto tmp2_done;
13690  }
13691  case 27: {
13692  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,23,2) == 0) goto tmp2_end;
13693 
13694  /* Pattern matching succeeded */
13695 #line 3682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13696  /* Tail recursive call */
13697 #line 3682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13698  _inExp = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 2)));
13699 #line 3682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13700  goto _tailrecursive;
13701 #line 3682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13702  /* TODO: Make sure any eventual dead code below is never generated */
13703 #line 13703 OMC_FILE
13704  goto tmp2_done;
13705  }
13706  case 28: {
13707 
13708  /* Pattern matching succeeded */
13709 #line 3686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13710  tmpMeta[1] = stringAppend(_OMC_LIT53,omc_Dump_printExpStr(threadData, _inExp));
13711 #line 3686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13712  omc_Error_addInternalError(threadData, tmpMeta[1], _OMC_LIT55);
13713 #line 13713 OMC_FILE
13714 #line 3687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13715  goto goto_1;
13716 #line 13716 OMC_FILE
13717  goto tmp2_done;
13718  }
13719  }
13720  goto tmp2_end;
13721  tmp2_end: ;
13722  }
13723  goto goto_1;
13724  goto_1:;
13725  MMC_THROW_INTERNAL();
13726  goto tmp2_done;
13727  tmp2_done:;
13728  }
13729  }
13730  _outComponentRefLst = tmpMeta[0];
13731  _return: OMC_LABEL_UNUSED
13732  return _outComponentRefLst;
13733 }
DLLExport modelica_metatype omc_Absyn_getCrefFromFarg(threadData_t *threadData, modelica_metatype _inFunctionArgs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13087
DLLExport modelica_metatype omc_List_map2List(threadData_t *threadData, modelica_metatype _inListList, modelica_fnptr _inFunc, modelica_metatype _inArg1, modelica_metatype _inArg2)
Definition: List.c:9689
signed char modelica_boolean
float mmc_switch_type
modelica_metatype listAppend(modelica_metatype, modelica_metatype)
DLLExport modelica_metatype omc_List_flatten(threadData_t *threadData, modelica_metatype _inList)
Definition: List.c:8242
DLLExport modelica_metatype omc_List_map2(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg1, modelica_metatype _inArg2)
Definition: List.c:12478
DLLExport modelica_metatype omc_Absyn_getSubsFromCref(threadData_t *threadData, modelica_metatype _cr, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:11171
DLLExport modelica_metatype omc_Absyn_getCrefFromExp(threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13198
modelica_string stringAppend(modelica_string s1, modelica_string s2)
DLLExport void omc_Error_addInternalError(threadData_t *threadData, modelica_string _message, modelica_metatype _info)
Definition: Error.c:135
void * modelica_metatype
DLLExport modelica_string omc_Dump_printExpStr(threadData_t *threadData, modelica_metatype _inExp)
Definition: Dump.c:10422
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_getCrefsFromSubs(threadData_t *threadData, modelica_metatype _isubs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13747
Here is the caller graph for this function:

◆ omc_Absyn_getCrefFromFarg()

DLLExport modelica_metatype omc_Absyn_getCrefFromFarg ( threadData_t threadData,
modelica_metatype  _inFunctionArgs,
modelica_boolean  _includeSubs,
modelica_boolean  _includeFunctions 
)

Definition at line 13087 of file Absyn.c.

13088 {
13089  modelica_metatype _outComponentRefLst = NULL;
13090  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
13091  MMC_SO();
13092  _tailrecursive: OMC_LABEL_UNUSED
13093 #line 13093 OMC_FILE
13094  { /* match expression */
13095  modelica_metatype tmp3_1;
13096  tmp3_1 = _inFunctionArgs;
13097  {
13098  modelica_metatype _l1 = NULL;
13099  modelica_metatype _l2 = NULL;
13100  modelica_metatype _fl1 = NULL;
13101  modelica_metatype _fl2 = NULL;
13102  modelica_metatype _fl3 = NULL;
13103  modelica_metatype _expl = NULL;
13104  modelica_metatype _nargl = NULL;
13105  modelica_metatype _iterators = NULL;
13106  modelica_metatype _exp = NULL;
13107  volatile mmc_switch_type tmp3;
13108  int tmp4;
13109  tmp3 = 0;
13110  for (; tmp3 < 2; tmp3++) {
13111  switch (MMC_SWITCH_CAST(tmp3)) {
13112  case 0: {
13113  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
13114  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13115  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
13116  _expl = tmpMeta[1];
13117  _nargl = tmpMeta[2];
13118  /* Pattern matching succeeded */
13119 #line 3709 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13120  _l1 = omc_List_map2(threadData, _expl, boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
13121 #line 13121 OMC_FILE
13122 
13123 #line 3710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13124  _fl1 = omc_List_flatten(threadData, _l1);
13125 #line 13125 OMC_FILE
13126 
13127 #line 3711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13128  _l2 = omc_List_map2(threadData, _nargl, boxvar_Absyn_getCrefFromNarg, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
13129 #line 13129 OMC_FILE
13130 
13131 #line 3712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13132  _fl2 = omc_List_flatten(threadData, _l2);
13133 #line 13133 OMC_FILE
13134 #line 3713 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13135  tmpMeta[0] = listAppend(_fl1, _fl2);
13136 #line 13136 OMC_FILE
13137  goto tmp2_done;
13138  }
13139  case 1: {
13140  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
13141  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
13142  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
13143  _exp = tmpMeta[1];
13144  _iterators = tmpMeta[2];
13145  /* Pattern matching succeeded */
13146 #line 3719 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13147  _l1 = omc_List_map2Option(threadData, omc_List_map(threadData, _iterators, boxvar_Absyn_iteratorRange), boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
13148 #line 13148 OMC_FILE
13149 
13150 #line 3720 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13151  _l2 = omc_List_map2Option(threadData, omc_List_map(threadData, _iterators, boxvar_Absyn_iteratorGuard), boxvar_Absyn_getCrefFromExp, mmc_mk_boolean(_includeSubs), mmc_mk_boolean(_includeFunctions));
13152 #line 13152 OMC_FILE
13153 
13154 #line 3721 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13155  _fl1 = omc_List_flatten(threadData, _l1);
13156 #line 13156 OMC_FILE
13157 
13158 #line 3722 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13159  _fl2 = omc_List_flatten(threadData, _l2);
13160 #line 13160 OMC_FILE
13161 
13162 #line 3723 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13163  _fl3 = omc_Absyn_getCrefFromExp(threadData, _exp, _includeSubs, _includeFunctions);
13164 #line 13164 OMC_FILE
13165 #line 3724 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13166  tmpMeta[0] = listAppend(_fl1, listAppend(_fl2, _fl3));
13167 #line 13167 OMC_FILE
13168  goto tmp2_done;
13169  }
13170  }
13171  goto tmp2_end;
13172  tmp2_end: ;
13173  }
13174  goto goto_1;
13175  goto_1:;
13176  MMC_THROW_INTERNAL();
13177  goto tmp2_done;
13178  tmp2_done:;
13179  }
13180  }
13181  _outComponentRefLst = tmpMeta[0];
13182  _return: OMC_LABEL_UNUSED
13183  return _outComponentRefLst;
13184 }
float mmc_switch_type
modelica_metatype listAppend(modelica_metatype, modelica_metatype)
DLLExport modelica_metatype omc_List_flatten(threadData_t *threadData, modelica_metatype _inList)
Definition: List.c:8242
DLLExport modelica_metatype omc_List_map2(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg1, modelica_metatype _inArg2)
Definition: List.c:12478
DLLExport modelica_metatype omc_List_map2Option(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg1, modelica_metatype _inArg2)
Definition: List.c:12947
DLLExport modelica_metatype omc_List_map(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc)
Definition: List.c:13453
DLLExport modelica_metatype omc_Absyn_getCrefFromExp(threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13198
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getCrefFromNarg()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getCrefFromNarg ( threadData_t threadData,
modelica_metatype  _inNamedArg,
modelica_boolean  _includeSubs,
modelica_boolean  _includeFunctions 
)

Definition at line 12890 of file Absyn.c.

12891 {
12892  modelica_metatype _outComponentRefLst = NULL;
12893  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
12894  MMC_SO();
12895  _tailrecursive: OMC_LABEL_UNUSED
12896 #line 12896 OMC_FILE
12897  { /* match expression */
12898  modelica_metatype tmp3_1;
12899  tmp3_1 = _inNamedArg;
12900  {
12901  modelica_metatype _exp = NULL;
12902  volatile mmc_switch_type tmp3;
12903  int tmp4;
12904  tmp3 = 0;
12905  for (; tmp3 < 1; tmp3++) {
12906  switch (MMC_SWITCH_CAST(tmp3)) {
12907  case 0: {
12908  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12909  _exp = tmpMeta[1];
12910  /* Pattern matching succeeded */
12911 #line 3789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12912  tmpMeta[0] = omc_Absyn_getCrefFromExp(threadData, _exp, _includeSubs, _includeFunctions);
12913 #line 12913 OMC_FILE
12914  goto tmp2_done;
12915  }
12916  }
12917  goto tmp2_end;
12918  tmp2_end: ;
12919  }
12920  goto goto_1;
12921  goto_1:;
12922  MMC_THROW_INTERNAL();
12923  goto tmp2_done;
12924  tmp2_done:;
12925  }
12926  }
12927  _outComponentRefLst = tmpMeta[0];
12928  _return: OMC_LABEL_UNUSED
12929  return _outComponentRefLst;
12930 }
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_getCrefFromExp(threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13198
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getCrefsFromSubs()

DLLExport modelica_metatype omc_Absyn_getCrefsFromSubs ( threadData_t threadData,
modelica_metatype  _isubs,
modelica_boolean  _includeSubs,
modelica_boolean  _includeFunctions 
)

Definition at line 13747 of file Absyn.c.

13748 {
13749  modelica_metatype _crefs = NULL;
13750  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
13751  MMC_SO();
13752  _tailrecursive: OMC_LABEL_UNUSED
13753 #line 13753 OMC_FILE
13754  { /* match expression */
13755  modelica_metatype tmp3_1;
13756  tmp3_1 = _isubs;
13757  {
13758  modelica_metatype _crefs1 = NULL;
13759  modelica_metatype _exp = NULL;
13760  modelica_metatype _subs = NULL;
13761  volatile mmc_switch_type tmp3;
13762  int tmp4;
13763  tmp3 = 0;
13764  for (; tmp3 < 3; tmp3++) {
13765  switch (MMC_SWITCH_CAST(tmp3)) {
13766  case 0: {
13767  if (!listEmpty(tmp3_1)) goto tmp2_end;
13768  /* Pattern matching succeeded */
13769 #line 3518 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13770  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
13771 #line 3518 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13772  tmpMeta[0] = tmpMeta[1];
13773 #line 13773 OMC_FILE
13774  goto tmp2_done;
13775  }
13776  case 1: {
13777  if (listEmpty(tmp3_1)) goto tmp2_end;
13778  tmpMeta[1] = MMC_CAR(tmp3_1);
13779  tmpMeta[2] = MMC_CDR(tmp3_1);
13780  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,0) == 0) goto tmp2_end;
13781  _subs = tmpMeta[2];
13782  /* Pattern matching succeeded */
13783 #line 3520 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13784  /* Tail recursive call */
13785 #line 3520 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13786  _isubs = _subs;
13787 #line 3520 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13788  goto _tailrecursive;
13789 #line 3520 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13790  /* TODO: Make sure any eventual dead code below is never generated */
13791 #line 13791 OMC_FILE
13792  goto tmp2_done;
13793  }
13794  case 2: {
13795  if (listEmpty(tmp3_1)) goto tmp2_end;
13796  tmpMeta[1] = MMC_CAR(tmp3_1);
13797  tmpMeta[2] = MMC_CDR(tmp3_1);
13798  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,1) == 0) goto tmp2_end;
13799  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
13800  _exp = tmpMeta[3];
13801  _subs = tmpMeta[2];
13802  /* Pattern matching succeeded */
13803 #line 3524 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13804  _crefs1 = omc_Absyn_getCrefsFromSubs(threadData, _subs, _includeSubs, _includeFunctions);
13805 #line 13805 OMC_FILE
13806 
13807 #line 3525 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13808  _crefs = omc_Absyn_getCrefFromExp(threadData, _exp, _includeSubs, _includeFunctions);
13809 #line 13809 OMC_FILE
13810 #line 3526 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13811  tmpMeta[0] = listAppend(_crefs, _crefs1);
13812 #line 13812 OMC_FILE
13813  goto tmp2_done;
13814  }
13815  }
13816  goto tmp2_end;
13817  tmp2_end: ;
13818  }
13819  goto goto_1;
13820  goto_1:;
13821  MMC_THROW_INTERNAL();
13822  goto tmp2_done;
13823  tmp2_done:;
13824  }
13825  }
13826  _crefs = tmpMeta[0];
13827  _return: OMC_LABEL_UNUSED
13828  return _crefs;
13829 }
float mmc_switch_type
modelica_metatype listAppend(modelica_metatype, modelica_metatype)
DLLExport modelica_metatype omc_Absyn_getCrefFromExp(threadData_t *threadData, modelica_metatype _inExp, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13198
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_getCrefsFromSubs(threadData_t *threadData, modelica_metatype _isubs, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:13747
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getDefineUnitsInElements()

DLLExport modelica_metatype omc_Absyn_getDefineUnitsInElements ( threadData_t threadData,
modelica_metatype  _elts 
)

Definition at line 3232 of file Absyn.c.

3233 {
3234  modelica_metatype _outElts = NULL;
3235  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
3236  MMC_SO();
3237  _tailrecursive: OMC_LABEL_UNUSED
3238 #line 3238 OMC_FILE
3239  { /* matchcontinue expression */
3240  volatile modelica_metatype tmp3_1;
3241  tmp3_1 = _elts;
3242  {
3243  modelica_metatype _e = NULL;
3244  modelica_metatype _rest = NULL;
3245  volatile mmc_switch_type tmp3;
3246  int tmp4;
3247  tmp3 = 0;
3248  MMC_TRY_INTERNAL(mmc_jumper)
3249  tmp2_top:
3250  threadData->mmc_jumper = &new_mmc_jumper;
3251  for (; tmp3 < 3; tmp3++) {
3252  switch (MMC_SWITCH_CAST(tmp3)) {
3253  case 0: {
3254  if (!listEmpty(tmp3_1)) goto tmp2_end;
3255  tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
3256 #line 6212 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3257  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
3258 #line 6212 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3259  tmpMeta[0] = tmpMeta[1];
3260 #line 3260 OMC_FILE
3261  goto tmp2_done;
3262  }
3263  case 1: {
3264  if (listEmpty(tmp3_1)) goto tmp2_end;
3265  tmpMeta[1] = MMC_CAR(tmp3_1);
3266  tmpMeta[2] = MMC_CDR(tmp3_1);
3267  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,1) == 0) goto tmp2_end;
3268  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
3269  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],1,2) == 0) goto tmp2_end;
3270 
3271  _e = tmpMeta[3];
3272  _rest = tmpMeta[2];
3273  /* Pattern matching succeeded */
3274 #line 6215 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3275  _outElts = omc_Absyn_getDefineUnitsInElements(threadData, _rest);
3276 #line 3276 OMC_FILE
3277 #line 6216 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3278  tmpMeta[1] = mmc_mk_cons(_e, _outElts);
3279 #line 6216 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3280  tmpMeta[0] = tmpMeta[1];
3281 #line 3281 OMC_FILE
3282  goto tmp2_done;
3283  }
3284  case 2: {
3285  if (listEmpty(tmp3_1)) goto tmp2_end;
3286  tmpMeta[1] = MMC_CAR(tmp3_1);
3287  tmpMeta[2] = MMC_CDR(tmp3_1);
3288  _rest = tmpMeta[2];
3289  /* Pattern matching succeeded */
3290 #line 6218 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3291  tmpMeta[0] = omc_Absyn_getDefineUnitsInElements(threadData, _rest);
3292 #line 3292 OMC_FILE
3293  goto tmp2_done;
3294  }
3295  }
3296  goto tmp2_end;
3297  tmp2_end: ;
3298  }
3299  goto goto_1;
3300  tmp2_done:
3301  (void)tmp3;
3302  MMC_RESTORE_INTERNAL(mmc_jumper);
3303  goto tmp2_done2;
3304  goto_1:;
3305  MMC_CATCH_INTERNAL(mmc_jumper);
3306  if (++tmp3 < 3) {
3307  goto tmp2_top;
3308  }
3309  MMC_THROW_INTERNAL();
3310  tmp2_done2:;
3311  }
3312  }
3313  _outElts = tmpMeta[0];
3314  _return: OMC_LABEL_UNUSED
3315  return _outElts;
3316 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
float mmc_switch_type
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_getDefineUnitsInElements(threadData_t *threadData, modelica_metatype _elts)
Definition: Absyn.c:3232
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getElementItemsInClass()

DLLExport modelica_metatype omc_Absyn_getElementItemsInClass ( threadData_t threadData,
modelica_metatype  _inClass 
)

Definition at line 3164 of file Absyn.c.

3165 {
3166  modelica_metatype _outElements = NULL;
3167  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
3168  MMC_SO();
3169  _tailrecursive: OMC_LABEL_UNUSED
3170 #line 3170 OMC_FILE
3171  { /* match expression */
3172  modelica_metatype tmp3_1;
3173  tmp3_1 = _inClass;
3174  {
3175  modelica_metatype _parts = NULL;
3176  volatile mmc_switch_type tmp3;
3177  int tmp4;
3178  tmp3 = 0;
3179  for (; tmp3 < 3; tmp3++) {
3180  switch (MMC_SWITCH_CAST(tmp3)) {
3181  case 0: {
3182  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
3183  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,5) == 0) goto tmp2_end;
3184  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 4));
3185 
3186  _parts = tmpMeta[2];
3187  /* Pattern matching succeeded */
3188 #line 6232 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3189  tmpMeta[0] = omc_List_mapFlat(threadData, _parts, boxvar_Absyn_getElementItemsInClassPart);
3190 #line 3190 OMC_FILE
3191  goto tmp2_done;
3192  }
3193  case 1: {
3194  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
3195  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],4,5) == 0) goto tmp2_end;
3196  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 5));
3197 
3198  _parts = tmpMeta[2];
3199  /* Pattern matching succeeded */
3200 #line 6235 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3201  tmpMeta[0] = omc_List_mapFlat(threadData, _parts, boxvar_Absyn_getElementItemsInClassPart);
3202 #line 3202 OMC_FILE
3203  goto tmp2_done;
3204  }
3205  case 2: {
3206 
3207  /* Pattern matching succeeded */
3208 #line 6237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3209  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
3210 #line 6237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3211  tmpMeta[0] = tmpMeta[1];
3212 #line 3212 OMC_FILE
3213  goto tmp2_done;
3214  }
3215  }
3216  goto tmp2_end;
3217  tmp2_end: ;
3218  }
3219  goto goto_1;
3220  goto_1:;
3221  MMC_THROW_INTERNAL();
3222  goto tmp2_done;
3223  tmp2_done:;
3224  }
3225  }
3226  _outElements = tmpMeta[0];
3227  _return: OMC_LABEL_UNUSED
3228  return _outElements;
3229 }
DLLExport modelica_metatype omc_List_mapFlat(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inMapFunc)
Definition: List.c:11331
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getElementItemsInClassPart()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getElementItemsInClassPart ( threadData_t threadData,
modelica_metatype  _inClassPart 
)

Definition at line 3101 of file Absyn.c.

3102 {
3103  modelica_metatype _outElements = NULL;
3104  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
3105  MMC_SO();
3106  _tailrecursive: OMC_LABEL_UNUSED
3107 #line 3107 OMC_FILE
3108  { /* match expression */
3109  modelica_metatype tmp3_1;
3110  tmp3_1 = _inClassPart;
3111  {
3112  modelica_metatype _elts = NULL;
3113  int tmp3;
3114  {
3115  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
3116  case 3: {
3117  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
3118  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
3119  _elts = tmpMeta[1];
3120  /* Pattern matching succeeded */
3121 #line 6251 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3122  tmpMeta[0] = _elts;
3123 #line 3123 OMC_FILE
3124  goto tmp2_done;
3125  }
3126  case 4: {
3127  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
3128  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
3129  _elts = tmpMeta[1];
3130  /* Pattern matching succeeded */
3131 #line 6252 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3132  tmpMeta[0] = _elts;
3133 #line 3133 OMC_FILE
3134  goto tmp2_done;
3135  }
3136  default:
3137  tmp2_default: OMC_LABEL_UNUSED; {
3138 
3139  /* Pattern matching succeeded */
3140 #line 6253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3141  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
3142 #line 6253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3143  tmpMeta[0] = tmpMeta[1];
3144 #line 3144 OMC_FILE
3145  goto tmp2_done;
3146  }
3147  }
3148  goto tmp2_end;
3149  tmp2_end: ;
3150  }
3151  goto goto_1;
3152  goto_1:;
3153  MMC_THROW_INTERNAL();
3154  goto tmp2_done;
3155  tmp2_done:;
3156  }
3157  }
3158  _outElements = tmpMeta[0];
3159  _return: OMC_LABEL_UNUSED
3160  return _outElements;
3161 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_getExpsFromArrayDim()

DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim ( threadData_t threadData,
modelica_metatype  _inAd,
modelica_metatype out_outExps 
)

Definition at line 6599 of file Absyn.c.

6600 {
6601  modelica_boolean _hasUnknownDimensions;
6602  modelica_metatype _outExps = NULL;
6603  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
6604  MMC_SO();
6605  _tailrecursive: OMC_LABEL_UNUSED
6606 #line 5349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6607  tmpMeta[0] = MMC_REFSTRUCTLIT(mmc_nil);
6608 #line 5349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6609  _hasUnknownDimensions = omc_Absyn_getExpsFromArrayDim__tail(threadData, _inAd, tmpMeta[0] ,&_outExps);
6610 #line 6610 OMC_FILE
6611  _return: OMC_LABEL_UNUSED
6612  if (out_outExps) { *out_outExps = _outExps; }
6613  return _hasUnknownDimensions;
6614 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim__tail(threadData_t *threadData, modelica_metatype _inAd, modelica_metatype _inAccumulator, modelica_metatype *out_outExps)
Definition: Absyn.c:6412
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getExpsFromArrayDim__tail()

DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim__tail ( threadData_t threadData,
modelica_metatype  _inAd,
modelica_metatype  _inAccumulator,
modelica_metatype out_outExps 
)

Definition at line 6412 of file Absyn.c.

6413 {
6414  modelica_boolean _hasUnknownDimensions;
6415  modelica_metatype _outExps = NULL;
6416  modelica_boolean tmp1_c0 __attribute__((unused)) = 0;
6417  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
6418  MMC_SO();
6419  _tailrecursive: OMC_LABEL_UNUSED
6420 #line 5383 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6421 
6422 #line 5383 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6423 
6424 #line 6424 OMC_FILE
6425  { /* match expression */
6426  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
6427  tmp4_1 = _inAd;
6428  tmp4_2 = _inAccumulator;
6429  {
6430  modelica_metatype _rest = NULL;
6431  modelica_metatype _e = NULL;
6432  modelica_metatype _exps = NULL;
6433  modelica_metatype _acc = NULL;
6434  volatile mmc_switch_type tmp4;
6435  int tmp5;
6436  tmp4 = 0;
6437  for (; tmp4 < 3; tmp4++) {
6438  switch (MMC_SWITCH_CAST(tmp4)) {
6439  case 0: {
6440  if (!listEmpty(tmp4_1)) goto tmp3_end;
6441 
6442  _acc = tmp4_2;
6443  /* Pattern matching succeeded */
6444 #line 5391 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6445  tmp1_c0 = 0;
6446 #line 5391 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6447  tmpMeta[0+1] = listReverse(_acc);
6448 #line 6448 OMC_FILE
6449  goto tmp3_done;
6450  }
6451  case 1: {
6452  if (listEmpty(tmp4_1)) goto tmp3_end;
6453  tmpMeta[2] = MMC_CAR(tmp4_1);
6454  tmpMeta[3] = MMC_CDR(tmp4_1);
6455  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],1,1) == 0) goto tmp3_end;
6456  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
6457 
6458  _e = tmpMeta[4];
6459  _rest = tmpMeta[3];
6460  _acc = tmp4_2;
6461  /* Pattern matching succeeded */
6462 #line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6463  tmpMeta[2] = mmc_mk_cons(_e, _acc);
6464 #line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6465  /* Tail recursive call */
6466 #line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6467  _inAd = _rest;
6468 #line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6469  _inAccumulator = tmpMeta[2];
6470 #line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6471  goto _tailrecursive;
6472 #line 5396 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6473  /* TODO: Make sure any eventual dead code below is never generated */
6474 #line 6474 OMC_FILE
6475  goto tmp3_done;
6476  }
6477  case 2: {
6478  if (listEmpty(tmp4_1)) goto tmp3_end;
6479  tmpMeta[2] = MMC_CAR(tmp4_1);
6480  tmpMeta[3] = MMC_CDR(tmp4_1);
6481  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],0,0) == 0) goto tmp3_end;
6482 
6483  _rest = tmpMeta[3];
6484  _acc = tmp4_2;
6485  /* Pattern matching succeeded */
6486 #line 5403 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6487  omc_Absyn_getExpsFromArrayDim__tail(threadData, _rest, _acc ,&_exps);
6488 #line 6488 OMC_FILE
6489 #line 5404 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6490  tmp1_c0 = 1;
6491 #line 5404 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6492  tmpMeta[0+1] = _exps;
6493 #line 6493 OMC_FILE
6494  goto tmp3_done;
6495  }
6496  }
6497  goto tmp3_end;
6498  tmp3_end: ;
6499  }
6500  goto goto_2;
6501  goto_2:;
6502  MMC_THROW_INTERNAL();
6503  goto tmp3_done;
6504  tmp3_done:;
6505  }
6506  }
6507  _hasUnknownDimensions = tmp1_c0;
6508  _outExps = tmpMeta[0+1];
6509  _return: OMC_LABEL_UNUSED
6510  if (out_outExps) { *out_outExps = _outExps; }
6511  return _hasUnknownDimensions;
6512 }
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim__tail(threadData_t *threadData, modelica_metatype _inAd, modelica_metatype _inAccumulator, modelica_metatype *out_outExps)
Definition: Absyn.c:6412
void * modelica_metatype
modelica_metatype listReverse(modelica_metatype)
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getExpsFromArrayDimOpt()

DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDimOpt ( threadData_t threadData,
modelica_metatype  _inAdO,
modelica_metatype out_outExps 
)

Definition at line 6524 of file Absyn.c.

6525 {
6526  modelica_boolean _hasUnknownDimensions;
6527  modelica_metatype _outExps = NULL;
6528  modelica_boolean tmp1_c0 __attribute__((unused)) = 0;
6529  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
6530  MMC_SO();
6531  _tailrecursive: OMC_LABEL_UNUSED
6532 #line 5360 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6533 
6534 #line 5360 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6535 
6536 #line 6536 OMC_FILE
6537  { /* match expression */
6538  modelica_metatype tmp4_1;
6539  tmp4_1 = _inAdO;
6540  {
6541  modelica_metatype _ad = NULL;
6542  volatile mmc_switch_type tmp4;
6543  int tmp5;
6544  tmp4 = 0;
6545  for (; tmp4 < 2; tmp4++) {
6546  switch (MMC_SWITCH_CAST(tmp4)) {
6547  case 0: {
6548  if (!optionNone(tmp4_1)) goto tmp3_end;
6549  /* Pattern matching succeeded */
6550 #line 5363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6551  tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
6552 #line 5363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6553  tmp1_c0 = 0;
6554 #line 5363 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6555  tmpMeta[0+1] = tmpMeta[2];
6556 #line 6556 OMC_FILE
6557  goto tmp3_done;
6558  }
6559  case 1: {
6560  if (optionNone(tmp4_1)) goto tmp3_end;
6561  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
6562  _ad = tmpMeta[2];
6563  /* Pattern matching succeeded */
6564 #line 5367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6565  tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
6566 #line 5367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6567  tmp1_c0 = omc_Absyn_getExpsFromArrayDim__tail(threadData, _ad, tmpMeta[2], &tmpMeta[0+1]);
6568 #line 6568 OMC_FILE
6569  goto tmp3_done;
6570  }
6571  }
6572  goto tmp3_end;
6573  tmp3_end: ;
6574  }
6575  goto goto_2;
6576  goto_2:;
6577  MMC_THROW_INTERNAL();
6578  goto tmp3_done;
6579  tmp3_done:;
6580  }
6581  }
6582  _hasUnknownDimensions = tmp1_c0;
6583  _outExps = tmpMeta[0+1];
6584  _return: OMC_LABEL_UNUSED
6585  if (out_outExps) { *out_outExps = _outExps; }
6586  return _hasUnknownDimensions;
6587 }
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_Absyn_getExpsFromArrayDim__tail(threadData_t *threadData, modelica_metatype _inAd, modelica_metatype _inAccumulator, modelica_metatype *out_outExps)
Definition: Absyn.c:6412
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getExternalDecl()

DLLExport modelica_metatype omc_Absyn_getExternalDecl ( threadData_t threadData,
modelica_metatype  _inCls 
)

Definition at line 5528 of file Absyn.c.

5529 {
5530  modelica_metatype _outExternal = NULL;
5531  modelica_metatype _cp = NULL;
5532  modelica_metatype _class_parts = NULL;
5533  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
5534  MMC_SO();
5535  _tailrecursive: OMC_LABEL_UNUSED
5536 #line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5537  /* Pattern-matching assignment */
5538 #line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5539  tmpMeta[0] = _inCls;
5540 #line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5541  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 7));
5542 #line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5543  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,5) == 0) MMC_THROW_INTERNAL();
5544 #line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5545  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 4));
5546 #line 5595 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5547  _class_parts = tmpMeta[2];
5548 #line 5548 OMC_FILE
5549 
5550 #line 5596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5551  _outExternal = omc_List_find(threadData, _class_parts, boxvar_Absyn_isExternalPart);
5552 #line 5552 OMC_FILE
5553  _return: OMC_LABEL_UNUSED
5554  return _outExternal;
5555 }
DLLExport modelica_metatype omc_List_find(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc)
Definition: List.c:3136
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getFileNameFromInfo()

DLLExport modelica_string omc_Absyn_getFileNameFromInfo ( threadData_t threadData,
modelica_metatype  _inInfo 
)

Definition at line 8829 of file Absyn.c.

8830 {
8831  modelica_string _inFileName = NULL;
8832  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
8833  MMC_SO();
8834  _tailrecursive: OMC_LABEL_UNUSED
8835 #line 4826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8836  /* Pattern-matching assignment */
8837 #line 4826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8838  tmpMeta[0] = _inInfo;
8839 #line 4826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8840  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
8841 #line 4826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8842  _inFileName = tmpMeta[1];
8843 #line 8843 OMC_FILE
8844  _return: OMC_LABEL_UNUSED
8845  return _inFileName;
8846 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_getFunctionInterface()

DLLExport modelica_metatype omc_Absyn_getFunctionInterface ( threadData_t threadData,
modelica_metatype  _cl 
)

Definition at line 5673 of file Absyn.c.

5674 {
5675  modelica_metatype _o = NULL;
5676  modelica_metatype tmpMeta[12] __attribute__((unused)) = {0};
5677  MMC_SO();
5678  _tailrecursive: OMC_LABEL_UNUSED
5679 #line 5679 OMC_FILE
5680  { /* match expression */
5681  modelica_metatype tmp3_1;
5682  tmp3_1 = _cl;
5683  {
5684  modelica_string _name = NULL;
5685  modelica_boolean _partialPrefix;
5686  modelica_boolean _finalPrefix;
5687  modelica_boolean _encapsulatedPrefix;
5688  modelica_metatype _info = NULL;
5689  modelica_metatype _typeVars = NULL;
5690  modelica_metatype _classParts = NULL;
5691  modelica_metatype _elts = NULL;
5692  modelica_metatype _funcRest = NULL;
5693  modelica_metatype _classAttr = NULL;
5694  volatile mmc_switch_type tmp3;
5695  int tmp4;
5696  tmp3 = 0;
5697  for (; tmp3 < 1; tmp3++) {
5698  switch (MMC_SWITCH_CAST(tmp3)) {
5699  case 0: {
5700  modelica_integer tmp5;
5701  modelica_integer tmp6;
5702  modelica_integer tmp7;
5703  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5704  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
5705  tmp5 = mmc_unbox_integer(tmpMeta[2]);
5706  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
5707  tmp6 = mmc_unbox_integer(tmpMeta[3]);
5708  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
5709  tmp7 = mmc_unbox_integer(tmpMeta[4]);
5710  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 6));
5711  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[5],9,1) == 0) goto tmp2_end;
5712  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
5713  tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
5714  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[7],0,5) == 0) goto tmp2_end;
5715  tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[7]), 2));
5716  tmpMeta[9] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[7]), 3));
5717  tmpMeta[10] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[7]), 4));
5718  tmpMeta[11] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 8));
5719  _name = tmpMeta[1];
5720  _partialPrefix = tmp5 /* pattern as ty=Boolean */;
5721  _finalPrefix = tmp6 /* pattern as ty=Boolean */;
5722  _encapsulatedPrefix = tmp7 /* pattern as ty=Boolean */;
5723  _funcRest = tmpMeta[6];
5724  _typeVars = tmpMeta[8];
5725  _classAttr = tmpMeta[9];
5726  _classParts = tmpMeta[10];
5727  _info = tmpMeta[11];
5728  /* Pattern matching succeeded */
5729 #line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5730  /* Pattern-matching assignment */
5731 #line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5732  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
5733 #line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5734  tmpMeta[2] = omc_List_fold(threadData, listReverse(_classParts), boxvar_Absyn_getFunctionInterfaceParts, tmpMeta[1]);
5735 #line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5736  if (listEmpty(tmpMeta[2])) goto goto_1;
5737 #line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5738  tmpMeta[3] = MMC_CAR(tmpMeta[2]);
5739 #line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5740  tmpMeta[4] = MMC_CDR(tmpMeta[2]);
5741 #line 5554 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5742  _elts = tmpMeta[2];
5743 #line 5743 OMC_FILE
5744 #line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5745  tmpMeta[1] = mmc_mk_box2(12, &Absyn_Restriction_R__FUNCTION__desc, _funcRest);
5746 #line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5747  tmpMeta[3] = mmc_mk_box2(3, &Absyn_ClassPart_PUBLIC__desc, _elts);
5748 #line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5749  tmpMeta[2] = mmc_mk_cons(tmpMeta[3], MMC_REFSTRUCTLIT(mmc_nil));
5750 #line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5751  tmpMeta[4] = MMC_REFSTRUCTLIT(mmc_nil);
5752 #line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5753  tmpMeta[5] = mmc_mk_box6(3, &Absyn_ClassDef_PARTS__desc, _typeVars, _classAttr, tmpMeta[2], tmpMeta[4], mmc_mk_none());
5754 #line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5755  tmpMeta[6] = mmc_mk_box8(3, &Absyn_Class_CLASS__desc, _name, mmc_mk_boolean(_partialPrefix), mmc_mk_boolean(_finalPrefix), mmc_mk_boolean(_encapsulatedPrefix), tmpMeta[1], tmpMeta[5], _info);
5756 #line 5555 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5757  tmpMeta[0] = tmpMeta[6];
5758 #line 5758 OMC_FILE
5759  goto tmp2_done;
5760  }
5761  }
5762  goto tmp2_end;
5763  tmp2_end: ;
5764  }
5765  goto goto_1;
5766  goto_1:;
5767  MMC_THROW_INTERNAL();
5768  goto tmp2_done;
5769  tmp2_done:;
5770  }
5771  }
5772  _o = tmpMeta[0];
5773  _return: OMC_LABEL_UNUSED
5774  return _o;
5775 }
modelica_metatype modelica_string
m_integer modelica_integer
signed char modelica_boolean
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassPart_PUBLIC__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Restriction_R__FUNCTION__desc
void * modelica_metatype
DLLExport modelica_metatype omc_List_fold(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFoldFunc, modelica_metatype _inStartValue)
Definition: List.c:9662
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassDef_PARTS__desc
modelica_metatype listReverse(modelica_metatype)
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Class_CLASS__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_getFunctionInterfaceParts()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getFunctionInterfaceParts ( threadData_t threadData,
modelica_metatype  _part,
modelica_metatype  _elts 
)

Definition at line 5614 of file Absyn.c.

5615 {
5616  modelica_metatype _oelts = NULL;
5617  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
5618  MMC_SO();
5619  _tailrecursive: OMC_LABEL_UNUSED
5620 #line 5620 OMC_FILE
5621  { /* match expression */
5622  modelica_metatype tmp3_1;modelica_metatype tmp3_2;
5623  tmp3_1 = _part;
5624  tmp3_2 = _elts;
5625  {
5626  modelica_metatype _elts1 = NULL;
5627  modelica_metatype _elts2 = NULL;
5628  volatile mmc_switch_type tmp3;
5629  int tmp4;
5630  tmp3 = 0;
5631  for (; tmp3 < 2; tmp3++) {
5632  switch (MMC_SWITCH_CAST(tmp3)) {
5633  case 0: {
5634  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
5635  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5636 
5637  _elts1 = tmpMeta[1];
5638  _elts2 = tmp3_2;
5639  /* Pattern matching succeeded */
5640 #line 5569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5641  _elts1 = omc_List_filterOnTrue(threadData, _elts1, boxvar_Absyn_filterAnnotationItem);
5642 #line 5642 OMC_FILE
5643 #line 5570 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5644  tmpMeta[0] = listAppend(_elts1, _elts2);
5645 #line 5645 OMC_FILE
5646  goto tmp2_done;
5647  }
5648  case 1: {
5649 
5650  /* Pattern matching succeeded */
5651 #line 5571 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5652  tmpMeta[0] = _elts;
5653 #line 5653 OMC_FILE
5654  goto tmp2_done;
5655  }
5656  }
5657  goto tmp2_end;
5658  tmp2_end: ;
5659  }
5660  goto goto_1;
5661  goto_1:;
5662  MMC_THROW_INTERNAL();
5663  goto tmp2_done;
5664  tmp2_done:;
5665  }
5666  }
5667  _oelts = tmpMeta[0];
5668  _return: OMC_LABEL_UNUSED
5669  return _oelts;
5670 }
float mmc_switch_type
modelica_metatype listAppend(modelica_metatype, modelica_metatype)
DLLExport modelica_metatype omc_List_filterOnTrue(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFilterFunc)
Definition: List.c:4218
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_getIteratorIndexedCrefs()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getIteratorIndexedCrefs ( threadData_t threadData,
modelica_metatype  _inCref,
modelica_string  _inIterator,
modelica_metatype  _inCrefs 
)

Definition at line 8931 of file Absyn.c.

8932 {
8933  modelica_metatype _outCrefs = NULL;
8934  modelica_metatype _crefs = NULL;
8935  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
8936  MMC_SO();
8937  _tailrecursive: OMC_LABEL_UNUSED
8938  _outCrefs = _inCrefs;
8939 #line 8939 OMC_FILE
8940  { /* match expression */
8941  modelica_metatype tmp3_1;
8942  tmp3_1 = _inCref;
8943  {
8944  modelica_metatype _subs = NULL;
8945  modelica_integer _idx;
8946  modelica_string _name = NULL;
8947  modelica_string _id = NULL;
8948  modelica_metatype _cref = NULL;
8949  int tmp3;
8950  {
8951  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
8952  case 5: {
8953  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
8954  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
8955  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
8956  _id = tmpMeta[1];
8957  _subs = tmpMeta[2];
8958  /* Pattern matching succeeded */
8959 #line 4760 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8960  _idx = ((modelica_integer) 1);
8961 #line 8961 OMC_FILE
8962 
8963 #line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8964  {
8965 #line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8966  modelica_metatype _sub;
8967 #line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8968  for (tmpMeta[1] = _subs; !listEmpty(tmpMeta[1]); tmpMeta[1]=MMC_CDR(tmpMeta[1]))
8969 #line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8970  {
8971 #line 4761 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8972  _sub = MMC_CAR(tmpMeta[1]);
8973 #line 8973 OMC_FILE
8974  { /* match expression */
8975  modelica_metatype tmp6_1;
8976  tmp6_1 = _sub;
8977  {
8978  volatile mmc_switch_type tmp6;
8979  int tmp7;
8980  tmp6 = 0;
8981  for (; tmp6 < 2; tmp6++) {
8982  switch (MMC_SWITCH_CAST(tmp6)) {
8983  case 0: {
8984  if (mmc__uniontype__metarecord__typedef__equal(tmp6_1,1,1) == 0) goto tmp5_end;
8985  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp6_1), 2));
8986  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],2,1) == 0) goto tmp5_end;
8987  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
8988  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],2,2) == 0) goto tmp5_end;
8989  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
8990  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 3));
8991  if (!listEmpty(tmpMeta[5])) goto tmp5_end;
8992  _name = tmpMeta[4];
8993  /* Pattern matching succeeded */
8994 #line 4766 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8995  if((stringEqual(_name, _inIterator)))
8996 #line 4766 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8997  {
8998 #line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8999  tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
9000 #line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9001  tmpMeta[4] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, tmpMeta[3]);
9002 #line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9003  tmpMeta[5] = mmc_mk_box2(0, tmpMeta[4], mmc_mk_integer((modelica_integer)_idx));
9004 #line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9005  tmpMeta[2] = mmc_mk_cons(tmpMeta[5], _outCrefs);
9006 #line 4767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9007  _outCrefs = tmpMeta[2];
9008 #line 9008 OMC_FILE
9009  }
9010 #line 9010 OMC_FILE
9011  goto tmp5_done;
9012  }
9013  case 1: {
9014 
9015  /* Pattern matching succeeded */
9016 #line 9016 OMC_FILE
9017  goto tmp5_done;
9018  }
9019  }
9020  goto tmp5_end;
9021  tmp5_end: ;
9022  }
9023  goto goto_4;
9024  goto_4:;
9025  goto goto_1;
9026  goto tmp5_done;
9027  tmp5_done:;
9028  }
9029  }
9030  ;
9031 
9032 #line 4775 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9033  _idx = ((modelica_integer) 1) + (modelica_integer)_idx;
9034 #line 9034 OMC_FILE
9035  }
9036  }
9037 #line 4777 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9038  tmpMeta[0] = _outCrefs;
9039 #line 9039 OMC_FILE
9040  goto tmp2_done;
9041  }
9042  case 4: {
9043  modelica_integer tmp8;
9044  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
9045  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
9046  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
9047  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
9048  _id = tmpMeta[1];
9049  _subs = tmpMeta[2];
9050  _cref = tmpMeta[3];
9051  /* Pattern matching succeeded */
9052 #line 4782 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9053  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
9054 #line 4782 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9055  _crefs = omc_Absyn_getIteratorIndexedCrefs(threadData, _cref, _inIterator, tmpMeta[1]);
9056 #line 9056 OMC_FILE
9057 
9058 #line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9059  {
9060 #line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9061  modelica_metatype _cr;
9062 #line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9063  for (tmpMeta[1] = _crefs; !listEmpty(tmpMeta[1]); tmpMeta[1]=MMC_CDR(tmpMeta[1]))
9064 #line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9065  {
9066 #line 4786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9067  _cr = MMC_CAR(tmpMeta[1]);
9068 #line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9069  /* Pattern-matching assignment */
9070 #line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9071  tmpMeta[2] = _cr;
9072 #line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9073  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
9074 #line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9075  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
9076 #line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9077  tmp8 = mmc_unbox_integer(tmpMeta[4]);
9078 #line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9079  _cref = tmpMeta[3];
9080 #line 4787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9081  _idx = tmp8 /* pattern as ty=Integer */;
9082 #line 9082 OMC_FILE
9083 
9084 #line 4788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9085  tmpMeta[3] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _subs, _cref);
9086 #line 4788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9087  tmpMeta[4] = mmc_mk_box2(0, tmpMeta[3], mmc_mk_integer((modelica_integer)_idx));
9088 #line 4788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9089  tmpMeta[2] = mmc_mk_cons(tmpMeta[4], _outCrefs);
9090 #line 4788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9091  _outCrefs = tmpMeta[2];
9092 #line 9092 OMC_FILE
9093  }
9094  }
9095 #line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9096  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _id, _subs);
9097 #line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9098  /* Tail recursive call */
9099 #line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9100  _inCref = tmpMeta[1];
9101 #line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9102  _inCrefs = _outCrefs;
9103 #line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9104  goto _tailrecursive;
9105 #line 4790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9106  /* TODO: Make sure any eventual dead code below is never generated */
9107 #line 9107 OMC_FILE
9108  goto tmp2_done;
9109  }
9110  case 3: {
9111  modelica_integer tmp9;
9112  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
9113  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
9114  _cref = tmpMeta[1];
9115  /* Pattern matching succeeded */
9116 #line 4795 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9117  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
9118 #line 4795 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9119  _crefs = omc_Absyn_getIteratorIndexedCrefs(threadData, _cref, _inIterator, tmpMeta[1]);
9120 #line 9120 OMC_FILE
9121 
9122 #line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9123  {
9124 #line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9125  modelica_metatype _cr;
9126 #line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9127  for (tmpMeta[1] = _crefs; !listEmpty(tmpMeta[1]); tmpMeta[1]=MMC_CDR(tmpMeta[1]))
9128 #line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9129  {
9130 #line 4798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9131  _cr = MMC_CAR(tmpMeta[1]);
9132 #line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9133  /* Pattern-matching assignment */
9134 #line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9135  tmpMeta[2] = _cr;
9136 #line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9137  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
9138 #line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9139  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
9140 #line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9141  tmp9 = mmc_unbox_integer(tmpMeta[4]);
9142 #line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9143  _cref = tmpMeta[3];
9144 #line 4799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9145  _idx = tmp9 /* pattern as ty=Integer */;
9146 #line 9146 OMC_FILE
9147 
9148 #line 4800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9149  tmpMeta[3] = mmc_mk_box2(3, &Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc, _cref);
9150 #line 4800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9151  tmpMeta[4] = mmc_mk_box2(0, tmpMeta[3], mmc_mk_integer((modelica_integer)_idx));
9152 #line 4800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9153  tmpMeta[2] = mmc_mk_cons(tmpMeta[4], _outCrefs);
9154 #line 4800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9155  _outCrefs = tmpMeta[2];
9156 #line 9156 OMC_FILE
9157  }
9158  }
9159 #line 4802 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9160  tmpMeta[0] = _outCrefs;
9161 #line 9161 OMC_FILE
9162  goto tmp2_done;
9163  }
9164  default:
9165  tmp2_default: OMC_LABEL_UNUSED; {
9166 
9167  /* Pattern matching succeeded */
9168 #line 4805 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9169  tmpMeta[0] = _inCrefs;
9170 #line 9170 OMC_FILE
9171  goto tmp2_done;
9172  }
9173  }
9174  goto tmp2_end;
9175  tmp2_end: ;
9176  }
9177  goto goto_1;
9178  goto_1:;
9179  MMC_THROW_INTERNAL();
9180  goto tmp2_done;
9181  tmp2_done:;
9182  }
9183  }
9184  _outCrefs = tmpMeta[0];
9185  _return: OMC_LABEL_UNUSED
9186  return _outCrefs;
9187 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
modelica_metatype modelica_string
m_integer modelica_integer
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getIteratorIndexedCrefs(threadData_t *threadData, modelica_metatype _inCref, modelica_string _inIterator, modelica_metatype _inCrefs)
Definition: Absyn.c:8931
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
int line
Definition: de.c:117
Here is the caller graph for this function:

◆ omc_Absyn_getNamedAnnotationInClass()

DLLExport modelica_metatype omc_Absyn_getNamedAnnotationInClass ( threadData_t threadData,
modelica_metatype  _inClass,
modelica_metatype  _id,
modelica_fnptr  _f 
)

Definition at line 3690 of file Absyn.c.

3691 {
3692  modelica_metatype _outString = NULL;
3693  modelica_metatype tmpMeta[7] __attribute__((unused)) = {0};
3694  MMC_SO();
3695  _tailrecursive: OMC_LABEL_UNUSED
3696 #line 3696 OMC_FILE
3697  { /* matchcontinue expression */
3698  volatile modelica_metatype tmp3_1;
3699  tmp3_1 = _inClass;
3700  {
3701  modelica_metatype _str = NULL;
3702  modelica_metatype _res = NULL;
3703  modelica_metatype _annlst = NULL;
3704  modelica_metatype _ann = NULL;
3705  volatile mmc_switch_type tmp3;
3706  int tmp4;
3707  tmp3 = 0;
3708  MMC_TRY_INTERNAL(mmc_jumper)
3709  tmp2_top:
3710  threadData->mmc_jumper = &new_mmc_jumper;
3711  for (; tmp3 < 6; tmp3++) {
3712  switch (MMC_SWITCH_CAST(tmp3)) {
3713  case 0: {
3714  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
3715  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,5) == 0) goto tmp2_end;
3716  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 5));
3717 
3718  _ann = tmpMeta[2];
3719  tmp3 += 4; /* Pattern matching succeeded; we may skip some cases if we fail */
3720 #line 6052 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3721  _annlst = omc_List_flatten(threadData, omc_List_map(threadData, _ann, boxvar_Absyn_annotationToElementArgs));
3722 #line 3722 OMC_FILE
3723 
3724 #line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3725  /* Pattern-matching assignment */
3726 #line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3727  tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
3728 #line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3729  if (optionNone(tmpMeta[1])) goto goto_1;
3730 #line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3731  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
3732 #line 6053 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3733  _str = tmpMeta[2];
3734 #line 3734 OMC_FILE
3735 #line 6054 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3736  tmpMeta[0] = mmc_mk_some(_str);
3737 #line 3737 OMC_FILE
3738  goto tmp2_done;
3739  }
3740  case 1: {
3741  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
3742  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],4,5) == 0) goto tmp2_end;
3743  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 6));
3744 
3745  _ann = tmpMeta[2];
3746  tmp3 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
3747 #line 6059 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3748  _annlst = omc_List_flatten(threadData, omc_List_map(threadData, _ann, boxvar_Absyn_annotationToElementArgs));
3749 #line 3749 OMC_FILE
3750 
3751 #line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3752  /* Pattern-matching assignment */
3753 #line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3754  tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
3755 #line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3756  if (optionNone(tmpMeta[1])) goto goto_1;
3757 #line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3758  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
3759 #line 6060 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3760  _str = tmpMeta[2];
3761 #line 3761 OMC_FILE
3762 #line 6061 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3763  tmpMeta[0] = mmc_mk_some(_str);
3764 #line 3764 OMC_FILE
3765  goto tmp2_done;
3766  }
3767  case 2: {
3768  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
3769  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,4) == 0) goto tmp2_end;
3770  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 5));
3771  if (optionNone(tmpMeta[2])) goto tmp2_end;
3772  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
3773  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
3774  if (optionNone(tmpMeta[4])) goto tmp2_end;
3775  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 1));
3776  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
3777 
3778  _annlst = tmpMeta[6];
3779  tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
3780 #line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3781  /* Pattern-matching assignment */
3782 #line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3783  tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
3784 #line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3785  if (optionNone(tmpMeta[1])) goto goto_1;
3786 #line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3787  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
3788 #line 6066 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3789  _res = tmpMeta[2];
3790 #line 3790 OMC_FILE
3791 #line 6067 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3792  tmpMeta[0] = mmc_mk_some(_res);
3793 #line 3793 OMC_FILE
3794  goto tmp2_done;
3795  }
3796  case 3: {
3797  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
3798  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto tmp2_end;
3799  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
3800  if (optionNone(tmpMeta[2])) goto tmp2_end;
3801  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
3802  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
3803  if (optionNone(tmpMeta[4])) goto tmp2_end;
3804  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 1));
3805  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
3806 
3807  _annlst = tmpMeta[6];
3808  tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
3809 #line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3810  /* Pattern-matching assignment */
3811 #line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3812  tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
3813 #line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3814  if (optionNone(tmpMeta[1])) goto goto_1;
3815 #line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3816  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
3817 #line 6072 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3818  _res = tmpMeta[2];
3819 #line 3819 OMC_FILE
3820 #line 6073 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3821  tmpMeta[0] = mmc_mk_some(_res);
3822 #line 3822 OMC_FILE
3823  goto tmp2_done;
3824  }
3825  case 4: {
3826  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
3827  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],3,2) == 0) goto tmp2_end;
3828  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
3829  if (optionNone(tmpMeta[2])) goto tmp2_end;
3830  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
3831  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
3832  if (optionNone(tmpMeta[4])) goto tmp2_end;
3833  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 1));
3834  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
3835 
3836  _annlst = tmpMeta[6];
3837  /* Pattern matching succeeded */
3838 #line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3839  /* Pattern-matching assignment */
3840 #line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3841  tmpMeta[1] = omc_Absyn_getNamedAnnotationStr(threadData, _annlst, _id, ((modelica_fnptr) _f));
3842 #line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3843  if (optionNone(tmpMeta[1])) goto goto_1;
3844 #line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3845  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
3846 #line 6078 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3847  _res = tmpMeta[2];
3848 #line 3848 OMC_FILE
3849 #line 6079 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3850  tmpMeta[0] = mmc_mk_some(_res);
3851 #line 3851 OMC_FILE
3852  goto tmp2_done;
3853  }
3854  case 5: {
3855 
3856  /* Pattern matching succeeded */
3857 #line 6082 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3858  tmpMeta[0] = mmc_mk_none();
3859 #line 3859 OMC_FILE
3860  goto tmp2_done;
3861  }
3862  }
3863  goto tmp2_end;
3864  tmp2_end: ;
3865  }
3866  goto goto_1;
3867  tmp2_done:
3868  (void)tmp3;
3869  MMC_RESTORE_INTERNAL(mmc_jumper);
3870  goto tmp2_done2;
3871  goto_1:;
3872  MMC_CATCH_INTERNAL(mmc_jumper);
3873  if (++tmp3 < 6) {
3874  goto tmp2_top;
3875  }
3876  MMC_THROW_INTERNAL();
3877  tmp2_done2:;
3878  }
3879  }
3880  _outString = tmpMeta[0];
3881  _return: OMC_LABEL_UNUSED
3882  return _outString;
3883 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
float mmc_switch_type
DLLExport modelica_metatype omc_List_flatten(threadData_t *threadData, modelica_metatype _inList)
Definition: List.c:8242
void * modelica_fnptr
DLLExport modelica_metatype omc_List_map(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc)
Definition: List.c:13453
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getNamedAnnotationStr(threadData_t *threadData, modelica_metatype _inAbsynElementArgLst, modelica_metatype _id, modelica_fnptr _f)
Definition: Absyn.c:3561
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getNamedAnnotationStr()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getNamedAnnotationStr ( threadData_t threadData,
modelica_metatype  _inAbsynElementArgLst,
modelica_metatype  _id,
modelica_fnptr  _f 
)

Definition at line 3561 of file Absyn.c.

3562 {
3563  modelica_metatype _outString = NULL;
3564  modelica_metatype tmpMeta[10] __attribute__((unused)) = {0};
3565  MMC_SO();
3566  _tailrecursive: OMC_LABEL_UNUSED
3567 #line 3567 OMC_FILE
3568  { /* matchcontinue expression */
3569  volatile modelica_metatype tmp3_1;volatile modelica_metatype tmp3_2;
3570  tmp3_1 = _inAbsynElementArgLst;
3571  tmp3_2 = _id;
3572  {
3573  modelica_metatype _str = NULL;
3574  modelica_metatype _mod = NULL;
3575  modelica_metatype _xs = NULL;
3576  modelica_string _id1 = NULL;
3577  modelica_string _id2 = NULL;
3578  modelica_metatype _rest = NULL;
3579  volatile mmc_switch_type tmp3;
3580  int tmp4;
3581  tmp3 = 0;
3582  MMC_TRY_INTERNAL(mmc_jumper)
3583  tmp2_top:
3584  threadData->mmc_jumper = &new_mmc_jumper;
3585  for (; tmp3 < 3; tmp3++) {
3586  switch (MMC_SWITCH_CAST(tmp3)) {
3587  case 0: {
3588  modelica_boolean tmp5;
3589  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,1,1) == 0) goto tmp2_end;
3590  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
3591  if (listEmpty(tmp3_1)) goto tmp2_end;
3592  tmpMeta[2] = MMC_CAR(tmp3_1);
3593  tmpMeta[3] = MMC_CDR(tmp3_1);
3594  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],0,6) == 0) goto tmp2_end;
3595  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 4));
3596  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],1,1) == 0) goto tmp2_end;
3597  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
3598  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 5));
3599 
3600  _id2 = tmpMeta[1];
3601  _id1 = tmpMeta[5];
3602  _mod = tmpMeta[6];
3603  tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
3604 #line 6110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3605  /* Pattern-matching assignment */
3606 #line 6110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3607  tmp5 = (stringEqual(_id1, _id2));
3608 #line 6110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3609  if (1 != tmp5) goto goto_1;
3610 #line 3610 OMC_FILE
3611 
3612 #line 6111 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3613  _str = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_f), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_f), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_f), 2))), _mod) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_f), 1)))) (threadData, _mod);
3614 #line 3614 OMC_FILE
3615 #line 6112 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3616  tmpMeta[0] = mmc_mk_some(_str);
3617 #line 3617 OMC_FILE
3618  goto tmp2_done;
3619  }
3620  case 1: {
3621  modelica_boolean tmp6;
3622  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,2) == 0) goto tmp2_end;
3623  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
3624  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 3));
3625  if (listEmpty(tmp3_1)) goto tmp2_end;
3626  tmpMeta[3] = MMC_CAR(tmp3_1);
3627  tmpMeta[4] = MMC_CDR(tmp3_1);
3628  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],0,6) == 0) goto tmp2_end;
3629  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 4));
3630  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[5],1,1) == 0) goto tmp2_end;
3631  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
3632  tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 5));
3633  if (optionNone(tmpMeta[7])) goto tmp2_end;
3634  tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[7]), 1));
3635  tmpMeta[9] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[8]), 2));
3636 
3637  _id2 = tmpMeta[1];
3638  _rest = tmpMeta[2];
3639  _id1 = tmpMeta[6];
3640  _xs = tmpMeta[9];
3641  /* Pattern matching succeeded */
3642 #line 6117 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3643  /* Pattern-matching assignment */
3644 #line 6117 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3645  tmp6 = (stringEqual(_id1, _id2));
3646 #line 6117 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3647  if (1 != tmp6) goto goto_1;
3648 #line 3648 OMC_FILE
3649 #line 6118 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3650  tmpMeta[0] = omc_Absyn_getNamedAnnotationStr(threadData, _xs, _rest, ((modelica_fnptr) _f));
3651 #line 3651 OMC_FILE
3652  goto tmp2_done;
3653  }
3654  case 2: {
3655  if (listEmpty(tmp3_1)) goto tmp2_end;
3656  tmpMeta[1] = MMC_CAR(tmp3_1);
3657  tmpMeta[2] = MMC_CDR(tmp3_1);
3658 
3659  _xs = tmpMeta[2];
3660  /* Pattern matching succeeded */
3661 #line 6120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3662  tmpMeta[0] = omc_Absyn_getNamedAnnotationStr(threadData, _xs, _id, ((modelica_fnptr) _f));
3663 #line 3663 OMC_FILE
3664  goto tmp2_done;
3665  }
3666  }
3667  goto tmp2_end;
3668  tmp2_end: ;
3669  }
3670  goto goto_1;
3671  tmp2_done:
3672  (void)tmp3;
3673  MMC_RESTORE_INTERNAL(mmc_jumper);
3674  goto tmp2_done2;
3675  goto_1:;
3676  MMC_CATCH_INTERNAL(mmc_jumper);
3677  if (++tmp3 < 3) {
3678  goto tmp2_top;
3679  }
3680  MMC_THROW_INTERNAL();
3681  tmp2_done2:;
3682  }
3683  }
3684  _outString = tmpMeta[0];
3685  _return: OMC_LABEL_UNUSED
3686  return _outString;
3687 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
void * modelica_fnptr
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_getNamedAnnotationStr(threadData_t *threadData, modelica_metatype _inAbsynElementArgLst, modelica_metatype _id, modelica_fnptr _f)
Definition: Absyn.c:3561
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the caller graph for this function:

◆ omc_Absyn_getNamedFuncArgNamesAndValues()

DLLExport modelica_metatype omc_Absyn_getNamedFuncArgNamesAndValues ( threadData_t threadData,
modelica_metatype  _inNamedArgList,
modelica_metatype out_outExpList 
)

Definition at line 12944 of file Absyn.c.

12945 {
12946  modelica_metatype _outStringList = NULL;
12947  modelica_metatype _outExpList = NULL;
12948  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
12949  MMC_SO();
12950  _tailrecursive: OMC_LABEL_UNUSED
12951 #line 3759 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12952 
12953 #line 3759 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12954 
12955 #line 12955 OMC_FILE
12956  { /* match expression */
12957  modelica_metatype tmp4_1;
12958  tmp4_1 = _inNamedArgList;
12959  {
12960  modelica_metatype _cdr = NULL;
12961  modelica_string _s = NULL;
12962  modelica_metatype _e = NULL;
12963  modelica_metatype _slst = NULL;
12964  modelica_metatype _elst = NULL;
12965  volatile mmc_switch_type tmp4;
12966  int tmp5;
12967  tmp4 = 0;
12968  for (; tmp4 < 2; tmp4++) {
12969  switch (MMC_SWITCH_CAST(tmp4)) {
12970  case 0: {
12971  if (!listEmpty(tmp4_1)) goto tmp3_end;
12972  /* Pattern matching succeeded */
12973 #line 3767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12974  tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
12975 #line 3767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12976  tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
12977 #line 3767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12978  tmpMeta[0+0] = tmpMeta[2];
12979 #line 3767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12980  tmpMeta[0+1] = tmpMeta[3];
12981 #line 12981 OMC_FILE
12982  goto tmp3_done;
12983  }
12984  case 1: {
12985  if (listEmpty(tmp4_1)) goto tmp3_end;
12986  tmpMeta[2] = MMC_CAR(tmp4_1);
12987  tmpMeta[3] = MMC_CDR(tmp4_1);
12988  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
12989  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 3));
12990  _s = tmpMeta[4];
12991  _e = tmpMeta[5];
12992  _cdr = tmpMeta[3];
12993  /* Pattern matching succeeded */
12994 #line 3770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12995  _slst = omc_Absyn_getNamedFuncArgNamesAndValues(threadData, _cdr ,&_elst);
12996 #line 12996 OMC_FILE
12997 #line 3771 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12998  tmpMeta[2] = mmc_mk_cons(_s, _slst);
12999 #line 3771 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13000  tmpMeta[3] = mmc_mk_cons(_e, _elst);
13001 #line 3771 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13002  tmpMeta[0+0] = tmpMeta[2];
13003 #line 3771 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13004  tmpMeta[0+1] = tmpMeta[3];
13005 #line 13005 OMC_FILE
13006  goto tmp3_done;
13007  }
13008  }
13009  goto tmp3_end;
13010  tmp3_end: ;
13011  }
13012  goto goto_2;
13013  goto_2:;
13014  MMC_THROW_INTERNAL();
13015  goto tmp3_done;
13016  tmp3_done:;
13017  }
13018  }
13019  _outStringList = tmpMeta[0+0];
13020  _outExpList = tmpMeta[0+1];
13021  _return: OMC_LABEL_UNUSED
13022  if (out_outExpList) { *out_outExpList = _outExpList; }
13023  return _outStringList;
13024 }
modelica_metatype modelica_string
DLLExport modelica_metatype omc_Absyn_getNamedFuncArgNamesAndValues(threadData_t *threadData, modelica_metatype _inNamedArgList, modelica_metatype *out_outExpList)
Definition: Absyn.c:12944
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_getShortClass()

DLLExport modelica_metatype omc_Absyn_getShortClass ( threadData_t threadData,
modelica_metatype  _cl 
)

Definition at line 5925 of file Absyn.c.

5926 {
5927  modelica_metatype _o = NULL;
5928  modelica_metatype tmpMeta[8] __attribute__((unused)) = {0};
5929  MMC_SO();
5930  _tailrecursive: OMC_LABEL_UNUSED
5931 #line 5931 OMC_FILE
5932  { /* match expression */
5933  modelica_metatype tmp3_1;
5934  tmp3_1 = _cl;
5935  {
5936  modelica_string _name = NULL;
5937  modelica_boolean _pa;
5938  modelica_boolean _fi;
5939  modelica_boolean _en;
5940  modelica_metatype _re = NULL;
5941  modelica_metatype _body = NULL;
5942  modelica_metatype _info = NULL;
5943  volatile mmc_switch_type tmp3;
5944  int tmp4;
5945  tmp3 = 0;
5946  for (; tmp3 < 3; tmp3++) {
5947  switch (MMC_SWITCH_CAST(tmp3)) {
5948  case 0: {
5949  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
5950  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,5) == 0) goto tmp2_end;
5951 
5952  /* Pattern matching succeeded */
5953 #line 5499 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5954  goto goto_1;
5955 #line 5955 OMC_FILE
5956  goto tmp2_done;
5957  }
5958  case 1: {
5959  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
5960  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],4,5) == 0) goto tmp2_end;
5961 
5962  /* Pattern matching succeeded */
5963 #line 5500 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5964  goto goto_1;
5965 #line 5965 OMC_FILE
5966  goto tmp2_done;
5967  }
5968  case 2: {
5969  modelica_integer tmp5;
5970  modelica_integer tmp6;
5971  modelica_integer tmp7;
5972  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5973  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
5974  tmp5 = mmc_unbox_integer(tmpMeta[2]);
5975  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
5976  tmp6 = mmc_unbox_integer(tmpMeta[3]);
5977  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
5978  tmp7 = mmc_unbox_integer(tmpMeta[4]);
5979  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 6));
5980  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 7));
5981  tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 8));
5982  _name = tmpMeta[1];
5983  _pa = tmp5 /* pattern as ty=Boolean */;
5984  _fi = tmp6 /* pattern as ty=Boolean */;
5985  _en = tmp7 /* pattern as ty=Boolean */;
5986  _re = tmpMeta[5];
5987  _body = tmpMeta[6];
5988  _info = tmpMeta[7];
5989  /* Pattern matching succeeded */
5990 #line 5503 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5991  _body = omc_Absyn_stripClassDefComment(threadData, _body);
5992 #line 5992 OMC_FILE
5993 #line 5504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5994  tmpMeta[1] = mmc_mk_box8(3, &Absyn_Class_CLASS__desc, _name, mmc_mk_boolean(_pa), mmc_mk_boolean(_fi), mmc_mk_boolean(_en), _re, _body, _info);
5995 #line 5504 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5996  tmpMeta[0] = tmpMeta[1];
5997 #line 5997 OMC_FILE
5998  goto tmp2_done;
5999  }
6000  }
6001  goto tmp2_end;
6002  tmp2_end: ;
6003  }
6004  goto goto_1;
6005  goto_1:;
6006  MMC_THROW_INTERNAL();
6007  goto tmp2_done;
6008  tmp2_done:;
6009  }
6010  }
6011  _o = tmpMeta[0];
6012  _return: OMC_LABEL_UNUSED
6013  return _o;
6014 }
modelica_metatype modelica_string
m_integer modelica_integer
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_stripClassDefComment(threadData_t *threadData, modelica_metatype _cl)
Definition: Absyn.c:5777
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Class_CLASS__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_getSubsFromCref()

DLLExport modelica_metatype omc_Absyn_getSubsFromCref ( threadData_t threadData,
modelica_metatype  _cr,
modelica_boolean  _includeSubs,
modelica_boolean  _includeFunctions 
)

Definition at line 11171 of file Absyn.c.

11172 {
11173  modelica_metatype _subscripts = NULL;
11174  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
11175  MMC_SO();
11176  _tailrecursive: OMC_LABEL_UNUSED
11177 #line 11177 OMC_FILE
11178  { /* match expression */
11179  modelica_metatype tmp3_1;
11180  tmp3_1 = _cr;
11181  {
11182  modelica_metatype _subs2 = NULL;
11183  modelica_metatype _child = NULL;
11184  int tmp3;
11185  {
11186  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
11187  case 5: {
11188  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
11189  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
11190  _subs2 = tmpMeta[1];
11191  /* Pattern matching succeeded */
11192 #line 4242 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11193  tmpMeta[0] = _subs2;
11194 #line 11194 OMC_FILE
11195  goto tmp2_done;
11196  }
11197  case 4: {
11198  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
11199  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
11200  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
11201  _subs2 = tmpMeta[1];
11202  _child = tmpMeta[2];
11203  /* Pattern matching succeeded */
11204 #line 4246 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11205  _subscripts = omc_Absyn_getSubsFromCref(threadData, _child, _includeSubs, _includeFunctions);
11206 #line 11206 OMC_FILE
11207 #line 4247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11208  tmpMeta[0] = omc_List_unionOnTrue(threadData, _subscripts, _subs2, boxvar_Absyn_subscriptEqual);
11209 #line 11209 OMC_FILE
11210  goto tmp2_done;
11211  }
11212  case 3: {
11213  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
11214  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11215  _child = tmpMeta[1];
11216  /* Pattern matching succeeded */
11217 #line 4253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11218  /* Tail recursive call */
11219 #line 4253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11220  _cr = _child;
11221 #line 4253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11222  goto _tailrecursive;
11223 #line 4253 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11224  /* TODO: Make sure any eventual dead code below is never generated */
11225 #line 11225 OMC_FILE
11226  goto tmp2_done;
11227  }
11228  }
11229  goto tmp2_end;
11230  tmp2_end: ;
11231  }
11232  goto goto_1;
11233  goto_1:;
11234  MMC_THROW_INTERNAL();
11235  goto tmp2_done;
11236  tmp2_done:;
11237  }
11238  }
11239  _subscripts = tmpMeta[0];
11240  _return: OMC_LABEL_UNUSED
11241  return _subscripts;
11242 }
DLLExport modelica_metatype omc_Absyn_getSubsFromCref(threadData_t *threadData, modelica_metatype _cr, modelica_boolean _includeSubs, modelica_boolean _includeFunctions)
Definition: Absyn.c:11171
DLLExport modelica_metatype omc_List_unionOnTrue(threadData_t *threadData, modelica_metatype _inList1, modelica_metatype _inList2, modelica_fnptr _inCompFunc)
Definition: List.c:13620
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_importEqual()

DLLExport modelica_boolean omc_Absyn_importEqual ( threadData_t threadData,
modelica_metatype  _im1,
modelica_metatype  _im2 
)

Definition at line 8142 of file Absyn.c.

8143 {
8144  modelica_boolean _outBoolean;
8145  modelica_boolean tmp1 = 0;
8146  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
8147  MMC_SO();
8148  _tailrecursive: OMC_LABEL_UNUSED
8149 #line 8149 OMC_FILE
8150  { /* matchcontinue expression */
8151  volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
8152  tmp4_1 = _im1;
8153  tmp4_2 = _im2;
8154  {
8155  modelica_string _id = NULL;
8156  modelica_string _id2 = NULL;
8157  modelica_metatype _p1 = NULL;
8158  modelica_metatype _p2 = NULL;
8159  volatile mmc_switch_type tmp4;
8160  int tmp5;
8161  tmp4 = 0;
8162  MMC_TRY_INTERNAL(mmc_jumper)
8163  tmp3_top:
8164  threadData->mmc_jumper = &new_mmc_jumper;
8165  for (; tmp4 < 4; tmp4++) {
8166  switch (MMC_SWITCH_CAST(tmp4)) {
8167  case 0: {
8168  modelica_boolean tmp6;
8169  modelica_boolean tmp7;
8170  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
8171  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
8172  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
8173  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
8174  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
8175  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
8176  _id = tmpMeta[0];
8177  _p1 = tmpMeta[1];
8178  _id2 = tmpMeta[2];
8179  _p2 = tmpMeta[3];
8180  tmp4 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
8181 #line 4947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8182  /* Pattern-matching assignment */
8183 #line 4947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8184  tmp6 = (stringEqual(_id, _id2));
8185 #line 4947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8186  if (1 != tmp6) goto goto_2;
8187 #line 8187 OMC_FILE
8188 
8189 #line 4948 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8190  /* Pattern-matching assignment */
8191 #line 4948 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8192  tmp7 = omc_Absyn_pathEqual(threadData, _p1, _p2);
8193 #line 4948 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8194  if (1 != tmp7) goto goto_2;
8195 #line 8195 OMC_FILE
8196 #line 4949 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8197  tmp1 = 1;
8198 #line 8198 OMC_FILE
8199  goto tmp3_done;
8200  }
8201  case 1: {
8202  modelica_boolean tmp8;
8203  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
8204  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
8205  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
8206  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
8207  _p1 = tmpMeta[0];
8208  _p2 = tmpMeta[1];
8209  tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
8210 #line 4953 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8211  /* Pattern-matching assignment */
8212 #line 4953 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8213  tmp8 = omc_Absyn_pathEqual(threadData, _p1, _p2);
8214 #line 4953 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8215  if (1 != tmp8) goto goto_2;
8216 #line 8216 OMC_FILE
8217 #line 4954 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8218  tmp1 = 1;
8219 #line 8219 OMC_FILE
8220  goto tmp3_done;
8221  }
8222  case 2: {
8223  modelica_boolean tmp9;
8224  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
8225  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
8226  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
8227  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
8228  _p1 = tmpMeta[0];
8229  _p2 = tmpMeta[1];
8230  /* Pattern matching succeeded */
8231 #line 4958 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8232  /* Pattern-matching assignment */
8233 #line 4958 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8234  tmp9 = omc_Absyn_pathEqual(threadData, _p1, _p2);
8235 #line 4958 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8236  if (1 != tmp9) goto goto_2;
8237 #line 8237 OMC_FILE
8238 #line 4959 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8239  tmp1 = 1;
8240 #line 8240 OMC_FILE
8241  goto tmp3_done;
8242  }
8243  case 3: {
8244 
8245  /* Pattern matching succeeded */
8246 #line 4961 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8247  tmp1 = 0;
8248 #line 8248 OMC_FILE
8249  goto tmp3_done;
8250  }
8251  }
8252  goto tmp3_end;
8253  tmp3_end: ;
8254  }
8255  goto goto_2;
8256  tmp3_done:
8257  (void)tmp4;
8258  MMC_RESTORE_INTERNAL(mmc_jumper);
8259  goto tmp3_done2;
8260  goto_2:;
8261  MMC_CATCH_INTERNAL(mmc_jumper);
8262  if (++tmp4 < 4) {
8263  goto tmp3_top;
8264  }
8265  MMC_THROW_INTERNAL();
8266  tmp3_done2:;
8267  }
8268  }
8269  _outBoolean = tmp1;
8270  _return: OMC_LABEL_UNUSED
8271  return _outBoolean;
8272 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
DLLExport modelica_boolean omc_Absyn_pathEqual(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:17616
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_importName()

DLLExport modelica_string omc_Absyn_importName ( threadData_t threadData,
modelica_metatype  _inImport 
)

Definition at line 4906 of file Absyn.c.

4907 {
4908  modelica_string _outName = NULL;
4909  modelica_string tmp1 = 0;
4910  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
4911  MMC_SO();
4912  _tailrecursive: OMC_LABEL_UNUSED
4913 #line 4913 OMC_FILE
4914  { /* match expression */
4915  modelica_metatype tmp4_1;
4916  tmp4_1 = _inImport;
4917  {
4918  modelica_string _name = NULL;
4919  modelica_metatype _path = NULL;
4920  volatile mmc_switch_type tmp4;
4921  int tmp5;
4922  tmp4 = 0;
4923  for (; tmp4 < 2; tmp4++) {
4924  switch (MMC_SWITCH_CAST(tmp4)) {
4925  case 0: {
4926  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
4927  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4928 
4929  _name = tmpMeta[0];
4930  /* Pattern matching succeeded */
4931 #line 5744 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4932  tmp1 = _name;
4933 #line 4933 OMC_FILE
4934  goto tmp3_done;
4935  }
4936  case 1: {
4937  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
4938  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4939  _path = tmpMeta[0];
4940  /* Pattern matching succeeded */
4941 #line 5746 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4942  tmp1 = omc_Absyn_pathLastIdent(threadData, _path);
4943 #line 4943 OMC_FILE
4944  goto tmp3_done;
4945  }
4946  }
4947  goto tmp3_end;
4948  tmp3_end: ;
4949  }
4950  goto goto_2;
4951  goto_2:;
4952  MMC_THROW_INTERNAL();
4953  goto tmp3_done;
4954  tmp3_done:;
4955  }
4956  }
4957  _outName = tmp1;
4958  _return: OMC_LABEL_UNUSED
4959  return _outName;
4960 }
modelica_metatype modelica_string
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_string omc_Absyn_pathLastIdent(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:15796
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_importPath()

DLLExport modelica_metatype omc_Absyn_importPath ( threadData_t threadData,
modelica_metatype  _inImport 
)

Definition at line 4963 of file Absyn.c.

4964 {
4965  modelica_metatype _outPath = NULL;
4966  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
4967  MMC_SO();
4968  _tailrecursive: OMC_LABEL_UNUSED
4969 #line 4969 OMC_FILE
4970  { /* match expression */
4971  modelica_metatype tmp3_1;
4972  tmp3_1 = _inImport;
4973  {
4974  modelica_metatype _path = NULL;
4975  int tmp3;
4976  {
4977  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
4978  case 3: {
4979  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
4980  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
4981  _path = tmpMeta[1];
4982  /* Pattern matching succeeded */
4983 #line 5725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4984  tmpMeta[0] = _path;
4985 #line 4985 OMC_FILE
4986  goto tmp2_done;
4987  }
4988  case 4: {
4989  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
4990  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
4991  _path = tmpMeta[1];
4992  /* Pattern matching succeeded */
4993 #line 5726 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4994  tmpMeta[0] = _path;
4995 #line 4995 OMC_FILE
4996  goto tmp2_done;
4997  }
4998  case 5: {
4999  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
5000  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5001  _path = tmpMeta[1];
5002  /* Pattern matching succeeded */
5003 #line 5727 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5004  tmpMeta[0] = _path;
5005 #line 5005 OMC_FILE
5006  goto tmp2_done;
5007  }
5008  case 6: {
5009  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,3,2) == 0) goto tmp2_end;
5010  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5011 
5012  _path = tmpMeta[1];
5013  /* Pattern matching succeeded */
5014 #line 5728 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5015  tmpMeta[0] = _path;
5016 #line 5016 OMC_FILE
5017  goto tmp2_done;
5018  }
5019  }
5020  goto tmp2_end;
5021  tmp2_end: ;
5022  }
5023  goto goto_1;
5024  goto_1:;
5025  MMC_THROW_INTERNAL();
5026  goto tmp2_done;
5027  tmp2_done:;
5028  }
5029  }
5030  _outPath = tmpMeta[0];
5031  _return: OMC_LABEL_UNUSED
5032  return _outPath;
5033 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_importString()

DLLExport modelica_string omc_Absyn_importString ( threadData_t threadData,
modelica_metatype  _inImp 
)

Definition at line 4250 of file Absyn.c.

4251 {
4252  modelica_string _outStr = NULL;
4253  MMC_SO();
4254  _tailrecursive: OMC_LABEL_UNUSED
4255 #line 5951 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4256  _outStr = omc_Dump_unparseImportStr(threadData, _inImp);
4257 #line 4257 OMC_FILE
4258  _return: OMC_LABEL_UNUSED
4259  return _outStr;
4260 }
modelica_metatype modelica_string
DLLExport modelica_string omc_Dump_unparseImportStr(threadData_t *threadData, modelica_metatype _inImport)
Definition: Dump.c:15155
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_innerOuterEqual()

DLLExport modelica_boolean omc_Absyn_innerOuterEqual ( threadData_t threadData,
modelica_metatype  _io1,
modelica_metatype  _io2 
)

Definition at line 8387 of file Absyn.c.

8388 {
8389  modelica_boolean _res;
8390  modelica_boolean tmp1 = 0;
8391  MMC_SO();
8392  _tailrecursive: OMC_LABEL_UNUSED
8393 #line 8393 OMC_FILE
8394  { /* match expression */
8395  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
8396  tmp4_1 = _io1;
8397  tmp4_2 = _io2;
8398  {
8399  volatile mmc_switch_type tmp4;
8400  int tmp5;
8401  tmp4 = 0;
8402  for (; tmp4 < 5; tmp4++) {
8403  switch (MMC_SWITCH_CAST(tmp4)) {
8404  case 0: {
8405  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
8406  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
8407  /* Pattern matching succeeded */
8408 #line 4905 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8409  tmp1 = 1;
8410 #line 8410 OMC_FILE
8411  goto tmp3_done;
8412  }
8413  case 1: {
8414  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
8415  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
8416  /* Pattern matching succeeded */
8417 #line 4906 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8418  tmp1 = 1;
8419 #line 8419 OMC_FILE
8420  goto tmp3_done;
8421  }
8422  case 2: {
8423  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,0) == 0) goto tmp3_end;
8424  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,0) == 0) goto tmp3_end;
8425  /* Pattern matching succeeded */
8426 #line 4907 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8427  tmp1 = 1;
8428 #line 8428 OMC_FILE
8429  goto tmp3_done;
8430  }
8431  case 3: {
8432  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
8433  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,3,0) == 0) goto tmp3_end;
8434  /* Pattern matching succeeded */
8435 #line 4908 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8436  tmp1 = 1;
8437 #line 8437 OMC_FILE
8438  goto tmp3_done;
8439  }
8440  case 4: {
8441 
8442  /* Pattern matching succeeded */
8443 #line 4909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8444  tmp1 = 0;
8445 #line 8445 OMC_FILE
8446  goto tmp3_done;
8447  }
8448  }
8449  goto tmp3_end;
8450  tmp3_end: ;
8451  }
8452  goto goto_2;
8453  goto_2:;
8454  MMC_THROW_INTERNAL();
8455  goto tmp3_done;
8456  tmp3_done:;
8457  }
8458  }
8459  _res = tmp1;
8460  _return: OMC_LABEL_UNUSED
8461  return _res;
8462 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_innerOuterStr()

DLLExport modelica_string omc_Absyn_innerOuterStr ( threadData_t threadData,
modelica_metatype  _io 
)

Definition at line 7113 of file Absyn.c.

7114 {
7115  modelica_string _str = NULL;
7116  modelica_string tmp1 = 0;
7117  MMC_SO();
7118  _tailrecursive: OMC_LABEL_UNUSED
7119 #line 7119 OMC_FILE
7120  { /* match expression */
7121  modelica_metatype tmp4_1;
7122  tmp4_1 = _io;
7123  {
7124  int tmp4;
7125  {
7126  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
7127  case 5: {
7128 
7129  /* Pattern matching succeeded */
7130 #line 5236 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7131  tmp1 = _OMC_LIT9;
7132 #line 7132 OMC_FILE
7133  goto tmp3_done;
7134  }
7135  case 3: {
7136 
7137  /* Pattern matching succeeded */
7138 #line 5237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7139  tmp1 = _OMC_LIT10;
7140 #line 7140 OMC_FILE
7141  goto tmp3_done;
7142  }
7143  case 4: {
7144 
7145  /* Pattern matching succeeded */
7146 #line 5238 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7147  tmp1 = _OMC_LIT11;
7148 #line 7148 OMC_FILE
7149  goto tmp3_done;
7150  }
7151  case 6: {
7152 
7153  /* Pattern matching succeeded */
7154 #line 5239 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7155  tmp1 = _OMC_LIT2;
7156 #line 7156 OMC_FILE
7157  goto tmp3_done;
7158  }
7159  }
7160  goto tmp3_end;
7161  tmp3_end: ;
7162  }
7163  goto goto_2;
7164  goto_2:;
7165  MMC_THROW_INTERNAL();
7166  goto tmp3_done;
7167  tmp3_done:;
7168  }
7169  }
7170  _str = tmp1;
7171  _return: OMC_LABEL_UNUSED
7172  return _str;
7173 }
modelica_metatype modelica_string
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isAlgorithmItem()

DLLExport modelica_boolean omc_Absyn_isAlgorithmItem ( threadData_t threadData,
modelica_metatype  _inAlg 
)

Definition at line 820 of file Absyn.c.

821 {
822  modelica_boolean _outIsClass;
823  modelica_boolean tmp1 = 0;
824  MMC_SO();
825  _tailrecursive: OMC_LABEL_UNUSED
826 #line 826 OMC_FILE
827  { /* match expression */
828  modelica_metatype tmp4_1;
829  tmp4_1 = _inAlg;
830  {
831  volatile mmc_switch_type tmp4;
832  int tmp5;
833  tmp4 = 0;
834  for (; tmp4 < 2; tmp4++) {
835  switch (MMC_SWITCH_CAST(tmp4)) {
836  case 0: {
837  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,3) == 0) goto tmp3_end;
838 
839  /* Pattern matching succeeded */
840 #line 6795 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
841  tmp1 = 1;
842 #line 842 OMC_FILE
843  goto tmp3_done;
844  }
845  case 1: {
846 
847  /* Pattern matching succeeded */
848 #line 6796 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
849  tmp1 = 0;
850 #line 850 OMC_FILE
851  goto tmp3_done;
852  }
853  }
854  goto tmp3_end;
855  tmp3_end: ;
856  }
857  goto goto_2;
858  goto_2:;
859  MMC_THROW_INTERNAL();
860  goto tmp3_done;
861  tmp3_done:;
862  }
863  }
864  _outIsClass = tmp1;
865  _return: OMC_LABEL_UNUSED
866  return _outIsClass;
867 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isClassdef()

DLLExport modelica_boolean omc_Absyn_isClassdef ( threadData_t threadData,
modelica_metatype  _inElement 
)

Definition at line 18003 of file Absyn.c.

18004 {
18005  modelica_boolean _b;
18006  modelica_boolean tmp1 = 0;
18007  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
18008  MMC_SO();
18009  _tailrecursive: OMC_LABEL_UNUSED
18010 #line 18010 OMC_FILE
18011  { /* match expression */
18012  modelica_metatype tmp4_1;
18013  tmp4_1 = _inElement;
18014  {
18015  volatile mmc_switch_type tmp4;
18016  int tmp5;
18017  tmp4 = 0;
18018  for (; tmp4 < 2; tmp4++) {
18019  switch (MMC_SWITCH_CAST(tmp4)) {
18020  case 0: {
18021  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
18022  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
18023  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,2) == 0) goto tmp3_end;
18024 
18025  /* Pattern matching succeeded */
18026 #line 2465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18027  tmp1 = 1;
18028 #line 18028 OMC_FILE
18029  goto tmp3_done;
18030  }
18031  case 1: {
18032 
18033  /* Pattern matching succeeded */
18034 #line 2466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18035  tmp1 = 0;
18036 #line 18036 OMC_FILE
18037  goto tmp3_done;
18038  }
18039  }
18040  goto tmp3_end;
18041  tmp3_end: ;
18042  }
18043  goto goto_2;
18044  goto_2:;
18045  MMC_THROW_INTERNAL();
18046  goto tmp3_done;
18047  tmp3_done:;
18048  }
18049  }
18050  _b = tmp1;
18051  _return: OMC_LABEL_UNUSED
18052  return _b;
18053 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isClassNamed()

DLLExport modelica_boolean omc_Absyn_isClassNamed ( threadData_t threadData,
modelica_string  _inName,
modelica_metatype  _inClass 
)

Definition at line 18127 of file Absyn.c.

18128 {
18129  modelica_boolean _outIsNamed;
18130  modelica_boolean tmp1 = 0;
18131  MMC_SO();
18132  _tailrecursive: OMC_LABEL_UNUSED
18133 #line 18133 OMC_FILE
18134  { /* match expression */
18135  modelica_metatype tmp4_1;
18136  tmp4_1 = _inClass;
18137  {
18138  volatile mmc_switch_type tmp4;
18139  int tmp5;
18140  tmp4 = 0;
18141  for (; tmp4 < 2; tmp4++) {
18142  switch (MMC_SWITCH_CAST(tmp4)) {
18143  case 0: {
18144 
18145  /* Pattern matching succeeded */
18146 #line 2441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18147  tmp1 = (stringEqual(_inName, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inClass), 2)))));
18148 #line 18148 OMC_FILE
18149  goto tmp3_done;
18150  }
18151  case 1: {
18152 
18153  /* Pattern matching succeeded */
18154 #line 2442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18155  tmp1 = 0;
18156 #line 18156 OMC_FILE
18157  goto tmp3_done;
18158  }
18159  }
18160  goto tmp3_end;
18161  tmp3_end: ;
18162  }
18163  goto goto_2;
18164  goto_2:;
18165  MMC_THROW_INTERNAL();
18166  goto tmp3_done;
18167  tmp3_done:;
18168  }
18169  }
18170  _outIsNamed = tmp1;
18171  _return: OMC_LABEL_UNUSED
18172  return _outIsNamed;
18173 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isCref()

DLLExport modelica_boolean omc_Absyn_isCref ( threadData_t threadData,
modelica_metatype  _exp 
)

Definition at line 6807 of file Absyn.c.

6808 {
6809  modelica_boolean _b;
6810  modelica_boolean tmp1 = 0;
6811  MMC_SO();
6812  _tailrecursive: OMC_LABEL_UNUSED
6813 #line 6813 OMC_FILE
6814  { /* match expression */
6815  modelica_metatype tmp4_1;
6816  tmp4_1 = _exp;
6817  {
6818  volatile mmc_switch_type tmp4;
6819  int tmp5;
6820  tmp4 = 0;
6821  for (; tmp4 < 2; tmp4++) {
6822  switch (MMC_SWITCH_CAST(tmp4)) {
6823  case 0: {
6824  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
6825 
6826  /* Pattern matching succeeded */
6827 #line 5310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6828  tmp1 = 1;
6829 #line 6829 OMC_FILE
6830  goto tmp3_done;
6831  }
6832  case 1: {
6833 
6834  /* Pattern matching succeeded */
6835 #line 5311 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6836  tmp1 = 0;
6837 #line 6837 OMC_FILE
6838  goto tmp3_done;
6839  }
6840  }
6841  goto tmp3_end;
6842  tmp3_end: ;
6843  }
6844  goto goto_2;
6845  goto_2:;
6846  MMC_THROW_INTERNAL();
6847  goto tmp3_done;
6848  tmp3_done:;
6849  }
6850  }
6851  _b = tmp1;
6852  _return: OMC_LABEL_UNUSED
6853  return _b;
6854 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isDerCref()

DLLExport modelica_boolean omc_Absyn_isDerCref ( threadData_t threadData,
modelica_metatype  _exp 
)

Definition at line 6675 of file Absyn.c.

6676 {
6677  modelica_boolean _b;
6678  modelica_boolean tmp1 = 0;
6679  modelica_metatype tmpMeta[8] __attribute__((unused)) = {0};
6680  MMC_SO();
6681  _tailrecursive: OMC_LABEL_UNUSED
6682 #line 6682 OMC_FILE
6683  { /* match expression */
6684  modelica_metatype tmp4_1;
6685  tmp4_1 = _exp;
6686  {
6687  volatile mmc_switch_type tmp4;
6688  int tmp5;
6689  tmp4 = 0;
6690  for (; tmp4 < 2; tmp4++) {
6691  switch (MMC_SWITCH_CAST(tmp4)) {
6692  case 0: {
6693  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
6694  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
6695  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],2,2) == 0) goto tmp3_end;
6696  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
6697  if (3 != MMC_STRLEN(tmpMeta[1]) || strcmp(MMC_STRINGDATA(_OMC_LIT8), MMC_STRINGDATA(tmpMeta[1])) != 0) goto tmp3_end;
6698  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
6699  if (!listEmpty(tmpMeta[2])) goto tmp3_end;
6700  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
6701  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],0,2) == 0) goto tmp3_end;
6702  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
6703  if (listEmpty(tmpMeta[4])) goto tmp3_end;
6704  tmpMeta[5] = MMC_CAR(tmpMeta[4]);
6705  tmpMeta[6] = MMC_CDR(tmpMeta[4]);
6706  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[5],2,1) == 0) goto tmp3_end;
6707  if (!listEmpty(tmpMeta[6])) goto tmp3_end;
6708  tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 3));
6709  if (!listEmpty(tmpMeta[7])) goto tmp3_end;
6710  /* Pattern matching succeeded */
6711 #line 5330 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6712  tmp1 = 1;
6713 #line 6713 OMC_FILE
6714  goto tmp3_done;
6715  }
6716  case 1: {
6717 
6718  /* Pattern matching succeeded */
6719 #line 5331 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6720  tmp1 = 0;
6721 #line 6721 OMC_FILE
6722  goto tmp3_done;
6723  }
6724  }
6725  goto tmp3_end;
6726  tmp3_end: ;
6727  }
6728  goto goto_2;
6729  goto_2:;
6730  MMC_THROW_INTERNAL();
6731  goto tmp3_done;
6732  tmp3_done:;
6733  }
6734  }
6735  _b = tmp1;
6736  _return: OMC_LABEL_UNUSED
6737  return _b;
6738 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isDerCrefFail()

DLLExport void omc_Absyn_isDerCrefFail ( threadData_t threadData,
modelica_metatype  _exp 
)

Definition at line 6626 of file Absyn.c.

6627 {
6628  modelica_metatype tmpMeta[9] __attribute__((unused)) = {0};
6629  MMC_SO();
6630  _tailrecursive: OMC_LABEL_UNUSED
6631 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6632  /* Pattern-matching assignment */
6633 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6634  tmpMeta[0] = _exp;
6635 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6636  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],11,2) == 0) MMC_THROW_INTERNAL();
6637 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6638  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
6639 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6640  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) MMC_THROW_INTERNAL();
6641 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6642  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
6643 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6644  if (3 != MMC_STRLEN(tmpMeta[2]) || strcmp("der", MMC_STRINGDATA(tmpMeta[2])) != 0) MMC_THROW_INTERNAL();
6645 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6646  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
6647 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6648  if (!listEmpty(tmpMeta[3])) MMC_THROW_INTERNAL();
6649 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6650  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
6651 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6652  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],0,2) == 0) MMC_THROW_INTERNAL();
6653 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6654  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
6655 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6656  if (listEmpty(tmpMeta[5])) MMC_THROW_INTERNAL();
6657 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6658  tmpMeta[6] = MMC_CAR(tmpMeta[5]);
6659 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6660  tmpMeta[7] = MMC_CDR(tmpMeta[5]);
6661 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6662  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[6],2,1) == 0) MMC_THROW_INTERNAL();
6663 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6664  if (!listEmpty(tmpMeta[7])) MMC_THROW_INTERNAL();
6665 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6666  tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 3));
6667 #line 5338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6668  if (!listEmpty(tmpMeta[8])) MMC_THROW_INTERNAL();
6669 #line 6669 OMC_FILE
6670  _return: OMC_LABEL_UNUSED
6671  return;
6672 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_isElementItem()

DLLExport modelica_boolean omc_Absyn_isElementItem ( threadData_t threadData,
modelica_metatype  _inElement 
)

Definition at line 878 of file Absyn.c.

879 {
880  modelica_boolean _outIsClass;
881  modelica_boolean tmp1 = 0;
882  MMC_SO();
883  _tailrecursive: OMC_LABEL_UNUSED
884 #line 884 OMC_FILE
885  { /* match expression */
886  modelica_metatype tmp4_1;
887  tmp4_1 = _inElement;
888  {
889  volatile mmc_switch_type tmp4;
890  int tmp5;
891  tmp4 = 0;
892  for (; tmp4 < 2; tmp4++) {
893  switch (MMC_SWITCH_CAST(tmp4)) {
894  case 0: {
895  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
896 
897  /* Pattern matching succeeded */
898 #line 6785 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
899  tmp1 = 1;
900 #line 900 OMC_FILE
901  goto tmp3_done;
902  }
903  case 1: {
904 
905  /* Pattern matching succeeded */
906 #line 6786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
907  tmp1 = 0;
908 #line 908 OMC_FILE
909  goto tmp3_done;
910  }
911  }
912  goto tmp3_end;
913  tmp3_end: ;
914  }
915  goto goto_2;
916  goto_2:;
917  MMC_THROW_INTERNAL();
918  goto tmp3_done;
919  tmp3_done:;
920  }
921  }
922  _outIsClass = tmp1;
923  _return: OMC_LABEL_UNUSED
924  return _outIsClass;
925 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isElementItemClass()

DLLExport modelica_boolean omc_Absyn_isElementItemClass ( threadData_t threadData,
modelica_metatype  _inElement 
)

Definition at line 936 of file Absyn.c.

937 {
938  modelica_boolean _outIsClass;
939  modelica_boolean tmp1 = 0;
940  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
941  MMC_SO();
942  _tailrecursive: OMC_LABEL_UNUSED
943 #line 943 OMC_FILE
944  { /* match expression */
945  modelica_metatype tmp4_1;
946  tmp4_1 = _inElement;
947  {
948  volatile mmc_switch_type tmp4;
949  int tmp5;
950  tmp4 = 0;
951  for (; tmp4 < 2; tmp4++) {
952  switch (MMC_SWITCH_CAST(tmp4)) {
953  case 0: {
954  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
955  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
956  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,6) == 0) goto tmp3_end;
957  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 5));
958  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,2) == 0) goto tmp3_end;
959 
960  /* Pattern matching succeeded */
961 #line 6775 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
962  tmp1 = 1;
963 #line 963 OMC_FILE
964  goto tmp3_done;
965  }
966  case 1: {
967 
968  /* Pattern matching succeeded */
969 #line 6776 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
970  tmp1 = 0;
971 #line 971 OMC_FILE
972  goto tmp3_done;
973  }
974  }
975  goto tmp3_end;
976  tmp3_end: ;
977  }
978  goto goto_2;
979  goto_2:;
980  MMC_THROW_INTERNAL();
981  goto tmp3_done;
982  tmp3_done:;
983  }
984  }
985  _outIsClass = tmp1;
986  _return: OMC_LABEL_UNUSED
987  return _outIsClass;
988 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isElementItemClassNamed()

DLLExport modelica_boolean omc_Absyn_isElementItemClassNamed ( threadData_t threadData,
modelica_string  _inName,
modelica_metatype  _inElement 
)

Definition at line 753 of file Absyn.c.

754 {
755  modelica_boolean _outIsNamed;
756  modelica_boolean tmp1 = 0;
757  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
758  MMC_SO();
759  _tailrecursive: OMC_LABEL_UNUSED
760 #line 760 OMC_FILE
761  { /* match expression */
762  modelica_metatype tmp4_1;
763  tmp4_1 = _inElement;
764  {
765  modelica_string _name = NULL;
766  volatile mmc_switch_type tmp4;
767  int tmp5;
768  tmp4 = 0;
769  for (; tmp4 < 2; tmp4++) {
770  switch (MMC_SWITCH_CAST(tmp4)) {
771  case 0: {
772  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
773  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
774  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,6) == 0) goto tmp3_end;
775  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 5));
776  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,2) == 0) goto tmp3_end;
777  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
778  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
779 
780  _name = tmpMeta[3];
781  /* Pattern matching succeeded */
782 #line 6810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
783  tmp1 = (stringEqual(_name, _inName));
784 #line 784 OMC_FILE
785  goto tmp3_done;
786  }
787  case 1: {
788 
789  /* Pattern matching succeeded */
790 #line 6811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
791  tmp1 = 0;
792 #line 792 OMC_FILE
793  goto tmp3_done;
794  }
795  }
796  goto tmp3_end;
797  tmp3_end: ;
798  }
799  goto goto_2;
800  goto_2:;
801  MMC_THROW_INTERNAL();
802  goto tmp3_done;
803  tmp3_done:;
804  }
805  }
806  _outIsNamed = tmp1;
807  _return: OMC_LABEL_UNUSED
808  return _outIsNamed;
809 }
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isEmptyClassPart()

DLLExport modelica_boolean omc_Absyn_isEmptyClassPart ( threadData_t threadData,
modelica_metatype  _inClassPart 
)

Definition at line 633 of file Absyn.c.

634 {
635  modelica_boolean _outIsEmpty;
636  modelica_boolean tmp1 = 0;
637  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
638  MMC_SO();
639  _tailrecursive: OMC_LABEL_UNUSED
640 #line 640 OMC_FILE
641  { /* match expression */
642  modelica_metatype tmp4_1;
643  tmp4_1 = _inClassPart;
644  {
645  volatile mmc_switch_type tmp4;
646  int tmp5;
647  tmp4 = 0;
648  for (; tmp4 < 8; tmp4++) {
649  switch (MMC_SWITCH_CAST(tmp4)) {
650  case 0: {
651  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
652  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
653  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
654  /* Pattern matching succeeded */
655 #line 6820 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
656  tmp1 = 1;
657 #line 657 OMC_FILE
658  goto tmp3_done;
659  }
660  case 1: {
661  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
662  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
663  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
664  /* Pattern matching succeeded */
665 #line 6821 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
666  tmp1 = 1;
667 #line 667 OMC_FILE
668  goto tmp3_done;
669  }
670  case 2: {
671  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
672  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
673  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
674  /* Pattern matching succeeded */
675 #line 6822 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
676  tmp1 = 1;
677 #line 677 OMC_FILE
678  goto tmp3_done;
679  }
680  case 3: {
681  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,1) == 0) goto tmp3_end;
682  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
683  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
684  /* Pattern matching succeeded */
685 #line 6823 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
686  tmp1 = 1;
687 #line 687 OMC_FILE
688  goto tmp3_done;
689  }
690  case 4: {
691  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,1) == 0) goto tmp3_end;
692  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
693  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
694  /* Pattern matching succeeded */
695 #line 6824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
696  tmp1 = 1;
697 #line 697 OMC_FILE
698  goto tmp3_done;
699  }
700  case 5: {
701  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,1) == 0) goto tmp3_end;
702  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
703  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
704  /* Pattern matching succeeded */
705 #line 6825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
706  tmp1 = 1;
707 #line 707 OMC_FILE
708  goto tmp3_done;
709  }
710  case 6: {
711  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,1) == 0) goto tmp3_end;
712  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
713  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
714  /* Pattern matching succeeded */
715 #line 6826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
716  tmp1 = 1;
717 #line 717 OMC_FILE
718  goto tmp3_done;
719  }
720  case 7: {
721 
722  /* Pattern matching succeeded */
723 #line 6827 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
724  tmp1 = 0;
725 #line 725 OMC_FILE
726  goto tmp3_done;
727  }
728  }
729  goto tmp3_end;
730  tmp3_end: ;
731  }
732  goto goto_2;
733  goto_2:;
734  MMC_THROW_INTERNAL();
735  goto tmp3_done;
736  tmp3_done:;
737  }
738  }
739  _outIsEmpty = tmp1;
740  _return: OMC_LABEL_UNUSED
741  return _outIsEmpty;
742 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isEmptyMod()

DLLExport modelica_boolean omc_Absyn_isEmptyMod ( threadData_t threadData,
modelica_metatype  _inMod 
)

Definition at line 2325 of file Absyn.c.

2326 {
2327  modelica_boolean _outIsEmpty;
2328  modelica_boolean tmp1 = 0;
2329  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
2330  MMC_SO();
2331  _tailrecursive: OMC_LABEL_UNUSED
2332 #line 2332 OMC_FILE
2333  { /* match expression */
2334  modelica_metatype tmp4_1;
2335  tmp4_1 = _inMod;
2336  {
2337  volatile mmc_switch_type tmp4;
2338  int tmp5;
2339  tmp4 = 0;
2340  for (; tmp4 < 3; tmp4++) {
2341  switch (MMC_SWITCH_CAST(tmp4)) {
2342  case 0: {
2343  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
2344  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
2345  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
2346  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,0) == 0) goto tmp3_end;
2347  /* Pattern matching succeeded */
2348 #line 6511 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2349  tmp1 = 1;
2350 #line 2350 OMC_FILE
2351  goto tmp3_done;
2352  }
2353  case 1: {
2354  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
2355  if (!listEmpty(tmpMeta[0])) goto tmp3_end;
2356  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
2357  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,2) == 0) goto tmp3_end;
2358  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
2359  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],16,1) == 0) goto tmp3_end;
2360  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
2361  if (!listEmpty(tmpMeta[3])) goto tmp3_end;
2362 
2363  /* Pattern matching succeeded */
2364 #line 6512 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2365  tmp1 = 1;
2366 #line 2366 OMC_FILE
2367  goto tmp3_done;
2368  }
2369  case 2: {
2370 
2371  /* Pattern matching succeeded */
2372 #line 6513 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2373  tmp1 = 0;
2374 #line 2374 OMC_FILE
2375  goto tmp3_done;
2376  }
2377  }
2378  goto tmp3_end;
2379  tmp3_end: ;
2380  }
2381  goto goto_2;
2382  goto_2:;
2383  MMC_THROW_INTERNAL();
2384  goto tmp3_done;
2385  tmp3_done:;
2386  }
2387  }
2388  _outIsEmpty = tmp1;
2389  _return: OMC_LABEL_UNUSED
2390  return _outIsEmpty;
2391 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isEmptySubMod()

DLLExport modelica_boolean omc_Absyn_isEmptySubMod ( threadData_t threadData,
modelica_metatype  _inSubMod 
)

Definition at line 2258 of file Absyn.c.

2259 {
2260  modelica_boolean _outIsEmpty;
2261  modelica_boolean tmp1 = 0;
2262  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
2263  MMC_SO();
2264  _tailrecursive: OMC_LABEL_UNUSED
2265 #line 2265 OMC_FILE
2266  { /* match expression */
2267  modelica_metatype tmp4_1;
2268  tmp4_1 = _inSubMod;
2269  {
2270  modelica_metatype _mod = NULL;
2271  volatile mmc_switch_type tmp4;
2272  int tmp5;
2273  tmp4 = 0;
2274  for (; tmp4 < 2; tmp4++) {
2275  switch (MMC_SWITCH_CAST(tmp4)) {
2276  case 0: {
2277  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
2278  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
2279  if (!optionNone(tmpMeta[0])) goto tmp3_end;
2280 
2281  /* Pattern matching succeeded */
2282 #line 6525 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2283  tmp1 = 1;
2284 #line 2284 OMC_FILE
2285  goto tmp3_done;
2286  }
2287  case 1: {
2288  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
2289  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
2290  if (optionNone(tmpMeta[0])) goto tmp3_end;
2291  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
2292 
2293  _mod = tmpMeta[1];
2294  /* Pattern matching succeeded */
2295 #line 6526 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2296  tmp1 = omc_Absyn_isEmptyMod(threadData, _mod);
2297 #line 2297 OMC_FILE
2298  goto tmp3_done;
2299  }
2300  }
2301  goto tmp3_end;
2302  tmp3_end: ;
2303  }
2304  goto goto_2;
2305  goto_2:;
2306  MMC_THROW_INTERNAL();
2307  goto tmp3_done;
2308  tmp3_done:;
2309  }
2310  }
2311  _outIsEmpty = tmp1;
2312  _return: OMC_LABEL_UNUSED
2313  return _outIsEmpty;
2314 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_isEmptyMod(threadData_t *threadData, modelica_metatype _inMod)
Definition: Absyn.c:2325
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_isExternalPart()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_isExternalPart ( threadData_t threadData,
modelica_metatype  _inClassPart 
)

Definition at line 5470 of file Absyn.c.

5471 {
5472  modelica_boolean _outFound;
5473  modelica_boolean tmp1 = 0;
5474  MMC_SO();
5475  _tailrecursive: OMC_LABEL_UNUSED
5476 #line 5476 OMC_FILE
5477  { /* match expression */
5478  modelica_metatype tmp4_1;
5479  tmp4_1 = _inClassPart;
5480  {
5481  volatile mmc_switch_type tmp4;
5482  int tmp5;
5483  tmp4 = 0;
5484  for (; tmp4 < 2; tmp4++) {
5485  switch (MMC_SWITCH_CAST(tmp4)) {
5486  case 0: {
5487  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,2) == 0) goto tmp3_end;
5488 
5489  /* Pattern matching succeeded */
5490 #line 5604 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5491  tmp1 = 1;
5492 #line 5492 OMC_FILE
5493  goto tmp3_done;
5494  }
5495  case 1: {
5496 
5497  /* Pattern matching succeeded */
5498 #line 5605 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5499  tmp1 = 0;
5500 #line 5500 OMC_FILE
5501  goto tmp3_done;
5502  }
5503  }
5504  goto tmp3_end;
5505  tmp3_end: ;
5506  }
5507  goto goto_2;
5508  goto_2:;
5509  MMC_THROW_INTERNAL();
5510  goto tmp3_done;
5511  tmp3_done:;
5512  }
5513  }
5514  _outFound = tmp1;
5515  _return: OMC_LABEL_UNUSED
5516  return _outFound;
5517 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isFieldEqual()

DLLExport modelica_boolean omc_Absyn_isFieldEqual ( threadData_t threadData,
modelica_metatype  _isField1,
modelica_metatype  _isField2 
)

Definition at line 6059 of file Absyn.c.

6060 {
6061  modelica_boolean _outEqual;
6062  modelica_boolean tmp1 = 0;
6063  MMC_SO();
6064  _tailrecursive: OMC_LABEL_UNUSED
6065 #line 6065 OMC_FILE
6066  { /* match expression */
6067  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
6068  tmp4_1 = _isField1;
6069  tmp4_2 = _isField2;
6070  {
6071  volatile mmc_switch_type tmp4;
6072  int tmp5;
6073  tmp4 = 0;
6074  for (; tmp4 < 3; tmp4++) {
6075  switch (MMC_SWITCH_CAST(tmp4)) {
6076  case 0: {
6077  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
6078  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
6079  /* Pattern matching succeeded */
6080 #line 5465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6081  tmp1 = 1;
6082 #line 6082 OMC_FILE
6083  goto tmp3_done;
6084  }
6085  case 1: {
6086  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
6087  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
6088  /* Pattern matching succeeded */
6089 #line 5466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6090  tmp1 = 1;
6091 #line 6091 OMC_FILE
6092  goto tmp3_done;
6093  }
6094  case 2: {
6095 
6096  /* Pattern matching succeeded */
6097 #line 5467 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6098  tmp1 = 0;
6099 #line 6099 OMC_FILE
6100  goto tmp3_done;
6101  }
6102  }
6103  goto tmp3_end;
6104  tmp3_end: ;
6105  }
6106  goto goto_2;
6107  goto_2:;
6108  MMC_THROW_INTERNAL();
6109  goto tmp3_done;
6110  tmp3_done:;
6111  }
6112  }
6113  _outEqual = tmp1;
6114  _return: OMC_LABEL_UNUSED
6115  return _outEqual;
6116 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isFunctionRestriction()

DLLExport modelica_boolean omc_Absyn_isFunctionRestriction ( threadData_t threadData,
modelica_metatype  _inRestriction 
)

Definition at line 9587 of file Absyn.c.

9588 {
9589  modelica_boolean _outIsFunction;
9590  modelica_boolean tmp1 = 0;
9591  MMC_SO();
9592  _tailrecursive: OMC_LABEL_UNUSED
9593 #line 9593 OMC_FILE
9594  { /* match expression */
9595  modelica_metatype tmp4_1;
9596  tmp4_1 = _inRestriction;
9597  {
9598  volatile mmc_switch_type tmp4;
9599  int tmp5;
9600  tmp4 = 0;
9601  for (; tmp4 < 2; tmp4++) {
9602  switch (MMC_SWITCH_CAST(tmp4)) {
9603  case 0: {
9604  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
9605 
9606  /* Pattern matching succeeded */
9607 #line 4615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9608  tmp1 = 1;
9609 #line 9609 OMC_FILE
9610  goto tmp3_done;
9611  }
9612  case 1: {
9613 
9614  /* Pattern matching succeeded */
9615 #line 4616 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9616  tmp1 = 0;
9617 #line 9617 OMC_FILE
9618  goto tmp3_done;
9619  }
9620  }
9621  goto tmp3_end;
9622  tmp3_end: ;
9623  }
9624  goto goto_2;
9625  goto_2:;
9626  MMC_THROW_INTERNAL();
9627  goto tmp3_done;
9628  tmp3_done:;
9629  }
9630  }
9631  _outIsFunction = tmp1;
9632  _return: OMC_LABEL_UNUSED
9633  return _outIsFunction;
9634 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isInitial()

DLLExport modelica_boolean omc_Absyn_isInitial ( threadData_t threadData,
modelica_metatype  _inExp 
)

Definition at line 5036 of file Absyn.c.

5037 {
5038  modelica_boolean _hasReinit;
5039  modelica_boolean tmp1 = 0;
5040  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
5041  MMC_SO();
5042  _tailrecursive: OMC_LABEL_UNUSED
5043 #line 5043 OMC_FILE
5044  { /* match expression */
5045  modelica_metatype tmp4_1;
5046  tmp4_1 = _inExp;
5047  {
5048  volatile mmc_switch_type tmp4;
5049  int tmp5;
5050  tmp4 = 0;
5051  for (; tmp4 < 3; tmp4++) {
5052  switch (MMC_SWITCH_CAST(tmp4)) {
5053  case 0: {
5054  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
5055  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
5056  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],2,2) == 0) goto tmp3_end;
5057  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
5058  if (7 != MMC_STRLEN(tmpMeta[1]) || strcmp(MMC_STRINGDATA(_OMC_LIT6), MMC_STRINGDATA(tmpMeta[1])) != 0) goto tmp3_end;
5059 
5060  /* Pattern matching succeeded */
5061 #line 5710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5062  tmp1 = 1;
5063 #line 5063 OMC_FILE
5064  goto tmp3_done;
5065  }
5066  case 1: {
5067  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
5068  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
5069  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
5070  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
5071  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto tmp3_end;
5072  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
5073  if (7 != MMC_STRLEN(tmpMeta[2]) || strcmp(MMC_STRINGDATA(_OMC_LIT6), MMC_STRINGDATA(tmpMeta[2])) != 0) goto tmp3_end;
5074 
5075  /* Pattern matching succeeded */
5076 #line 5711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5077  tmp1 = 1;
5078 #line 5078 OMC_FILE
5079  goto tmp3_done;
5080  }
5081  case 2: {
5082 
5083  /* Pattern matching succeeded */
5084 #line 5712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5085  tmp1 = 0;
5086 #line 5086 OMC_FILE
5087  goto tmp3_done;
5088  }
5089  }
5090  goto tmp3_end;
5091  tmp3_end: ;
5092  }
5093  goto goto_2;
5094  goto_2:;
5095  MMC_THROW_INTERNAL();
5096  goto tmp3_done;
5097  tmp3_done:;
5098  }
5099  }
5100  _hasReinit = tmp1;
5101  _return: OMC_LABEL_UNUSED
5102  return _hasReinit;
5103 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isInitialTraverseHelper()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_isInitialTraverseHelper ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_boolean  _inBool,
modelica_boolean out_outBool 
)

Definition at line 5113 of file Absyn.c.

5114 {
5115  modelica_metatype _outExp = NULL;
5116  modelica_boolean _outBool;
5117  modelica_boolean tmp1_c1 __attribute__((unused)) = 0;
5118  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
5119  MMC_SO();
5120  _tailrecursive: OMC_LABEL_UNUSED
5121 #line 5689 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5122 
5123 #line 5689 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5124 
5125 #line 5125 OMC_FILE
5126  { /* match expression */
5127  modelica_metatype tmp4_1;
5128  tmp4_1 = _inExp;
5129  {
5130  modelica_metatype _e = NULL;
5131  modelica_boolean _b;
5132  volatile mmc_switch_type tmp4;
5133  int tmp5;
5134  tmp4 = 0;
5135  for (; tmp4 < 3; tmp4++) {
5136  switch (MMC_SWITCH_CAST(tmp4)) {
5137  case 0: {
5138  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
5139  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
5140  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],16,0) == 0) goto tmp3_end;
5141 
5142  /* Pattern matching succeeded */
5143 #line 5693 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5144  tmpMeta[0+0] = _inExp;
5145 #line 5693 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5146  tmp1_c1 = _inBool;
5147 #line 5147 OMC_FILE
5148  goto tmp3_done;
5149  }
5150  case 1: {
5151 
5152  _e = tmp4_1;
5153  /* Pattern matching succeeded */
5154 #line 5697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5155  _b = omc_Absyn_isInitial(threadData, _e);
5156 #line 5156 OMC_FILE
5157 #line 5698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5158  tmpMeta[0+0] = _e;
5159 #line 5698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5160  tmp1_c1 = _b;
5161 #line 5161 OMC_FILE
5162  goto tmp3_done;
5163  }
5164  case 2: {
5165 
5166  /* Pattern matching succeeded */
5167 #line 5699 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5168  tmpMeta[0+0] = _inExp;
5169 #line 5699 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5170  tmp1_c1 = _inBool;
5171 #line 5171 OMC_FILE
5172  goto tmp3_done;
5173  }
5174  }
5175  goto tmp3_end;
5176  tmp3_end: ;
5177  }
5178  goto goto_2;
5179  goto_2:;
5180  MMC_THROW_INTERNAL();
5181  goto tmp3_done;
5182  tmp3_done:;
5183  }
5184  }
5185  _outExp = tmpMeta[0+0];
5186  _outBool = tmp1_c1;
5187  _return: OMC_LABEL_UNUSED
5188  if (out_outBool) { *out_outBool = _outBool; }
5189  return _outExp;
5190 }
DLLExport modelica_boolean omc_Absyn_isInitial(threadData_t *threadData, modelica_metatype _inExp)
Definition: Absyn.c:5036
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_isInner()

DLLExport modelica_boolean omc_Absyn_isInner ( threadData_t threadData,
modelica_metatype  _io 
)

Definition at line 8701 of file Absyn.c.

8702 {
8703  modelica_boolean _isItAnInner;
8704  modelica_boolean tmp1 = 0;
8705  MMC_SO();
8706  _tailrecursive: OMC_LABEL_UNUSED
8707 #line 8707 OMC_FILE
8708  { /* match expression */
8709  modelica_metatype tmp4_1;
8710  tmp4_1 = _io;
8711  {
8712  int tmp4;
8713  {
8714  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
8715  case 5: {
8716 
8717  /* Pattern matching succeeded */
8718 #line 4851 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8719  tmp1 = 1;
8720 #line 8720 OMC_FILE
8721  goto tmp3_done;
8722  }
8723  case 3: {
8724 
8725  /* Pattern matching succeeded */
8726 #line 4852 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8727  tmp1 = 1;
8728 #line 8728 OMC_FILE
8729  goto tmp3_done;
8730  }
8731  default:
8732  tmp3_default: OMC_LABEL_UNUSED; {
8733 
8734  /* Pattern matching succeeded */
8735 #line 4853 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8736  tmp1 = 0;
8737 #line 8737 OMC_FILE
8738  goto tmp3_done;
8739  }
8740  }
8741  goto tmp3_end;
8742  tmp3_end: ;
8743  }
8744  goto goto_2;
8745  goto_2:;
8746  MMC_THROW_INTERNAL();
8747  goto tmp3_done;
8748  tmp3_done:;
8749  }
8750  }
8751  _isItAnInner = tmp1;
8752  _return: OMC_LABEL_UNUSED
8753  return _isItAnInner;
8754 }
signed char modelica_boolean
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isInnerOuter()

DLLExport modelica_boolean omc_Absyn_isInnerOuter ( threadData_t threadData,
modelica_metatype  _inIO 
)

Definition at line 8530 of file Absyn.c.

8531 {
8532  modelica_boolean _outIsInnerOuter;
8533  modelica_boolean tmp1 = 0;
8534  MMC_SO();
8535  _tailrecursive: OMC_LABEL_UNUSED
8536 #line 8536 OMC_FILE
8537  { /* match expression */
8538  modelica_metatype tmp4_1;
8539  tmp4_1 = _inIO;
8540  {
8541  volatile mmc_switch_type tmp4;
8542  int tmp5;
8543  tmp4 = 0;
8544  for (; tmp4 < 2; tmp4++) {
8545  switch (MMC_SWITCH_CAST(tmp4)) {
8546  case 0: {
8547  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,0) == 0) goto tmp3_end;
8548  /* Pattern matching succeeded */
8549 #line 4884 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8550  tmp1 = 1;
8551 #line 8551 OMC_FILE
8552  goto tmp3_done;
8553  }
8554  case 1: {
8555 
8556  /* Pattern matching succeeded */
8557 #line 4885 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8558  tmp1 = 0;
8559 #line 8559 OMC_FILE
8560  goto tmp3_done;
8561  }
8562  }
8563  goto tmp3_end;
8564  tmp3_end: ;
8565  }
8566  goto goto_2;
8567  goto_2:;
8568  MMC_THROW_INTERNAL();
8569  goto tmp3_done;
8570  tmp3_done:;
8571  }
8572  }
8573  _outIsInnerOuter = tmp1;
8574  _return: OMC_LABEL_UNUSED
8575  return _outIsInnerOuter;
8576 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isInput()

DLLExport modelica_boolean omc_Absyn_isInput ( threadData_t threadData,
modelica_metatype  _inDirection 
)

Definition at line 6277 of file Absyn.c.

6278 {
6279  modelica_boolean _outIsInput;
6280  modelica_boolean tmp1 = 0;
6281  MMC_SO();
6282  _tailrecursive: OMC_LABEL_UNUSED
6283 #line 6283 OMC_FILE
6284  { /* match expression */
6285  modelica_metatype tmp4_1;
6286  tmp4_1 = _inDirection;
6287  {
6288  int tmp4;
6289  {
6290  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
6291  case 3: {
6292 
6293  /* Pattern matching succeeded */
6294 #line 5428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6295  tmp1 = 1;
6296 #line 6296 OMC_FILE
6297  goto tmp3_done;
6298  }
6299  case 6: {
6300 
6301  /* Pattern matching succeeded */
6302 #line 5429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6303  tmp1 = 1;
6304 #line 6304 OMC_FILE
6305  goto tmp3_done;
6306  }
6307  default:
6308  tmp3_default: OMC_LABEL_UNUSED; {
6309 
6310  /* Pattern matching succeeded */
6311 #line 5430 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6312  tmp1 = 0;
6313 #line 6313 OMC_FILE
6314  goto tmp3_done;
6315  }
6316  }
6317  goto tmp3_end;
6318  tmp3_end: ;
6319  }
6320  goto goto_2;
6321  goto_2:;
6322  MMC_THROW_INTERNAL();
6323  goto tmp3_done;
6324  tmp3_done:;
6325  }
6326  }
6327  _outIsInput = tmp1;
6328  _return: OMC_LABEL_UNUSED
6329  return _outIsInput;
6330 }
signed char modelica_boolean
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isInputOrOutput()

DLLExport modelica_boolean omc_Absyn_isInputOrOutput ( threadData_t threadData,
modelica_metatype  _direction 
)

Definition at line 6341 of file Absyn.c.

6342 {
6343  modelica_boolean _isIorO;
6344  modelica_boolean tmp1 = 0;
6345  MMC_SO();
6346  _tailrecursive: OMC_LABEL_UNUSED
6347 #line 6347 OMC_FILE
6348  { /* match expression */
6349  modelica_metatype tmp4_1;
6350  tmp4_1 = _direction;
6351  {
6352  int tmp4;
6353  {
6354  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
6355  case 3: {
6356 
6357  /* Pattern matching succeeded */
6358 #line 5416 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6359  tmp1 = 1;
6360 #line 6360 OMC_FILE
6361  goto tmp3_done;
6362  }
6363  case 4: {
6364 
6365  /* Pattern matching succeeded */
6366 #line 5417 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6367  tmp1 = 1;
6368 #line 6368 OMC_FILE
6369  goto tmp3_done;
6370  }
6371  case 6: {
6372 
6373  /* Pattern matching succeeded */
6374 #line 5418 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6375  tmp1 = 1;
6376 #line 6376 OMC_FILE
6377  goto tmp3_done;
6378  }
6379  case 5: {
6380 
6381  /* Pattern matching succeeded */
6382 #line 5419 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6383  tmp1 = 0;
6384 #line 6384 OMC_FILE
6385  goto tmp3_done;
6386  }
6387  }
6388  goto tmp3_end;
6389  tmp3_end: ;
6390  }
6391  goto goto_2;
6392  goto_2:;
6393  MMC_THROW_INTERNAL();
6394  goto tmp3_done;
6395  tmp3_done:;
6396  }
6397  }
6398  _isIorO = tmp1;
6399  _return: OMC_LABEL_UNUSED
6400  return _isIorO;
6401 }
signed char modelica_boolean
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isInvariantExpNoTraverse()

DLLExport modelica_metatype omc_Absyn_isInvariantExpNoTraverse ( threadData_t threadData,
modelica_metatype $in_e,
modelica_boolean $in_b,
modelica_boolean out_b 
)

Definition at line 410 of file Absyn.c.

411 {
412  modelica_metatype _e = NULL;
413  modelica_boolean _b;
414  modelica_boolean tmp1 = 0;
415  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
416  MMC_SO();
417  _tailrecursive: OMC_LABEL_UNUSED
418  _e = _$in_e;
419  _b = _$in_b;
420 #line 6835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
421  if((!_b))
422 #line 6835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
423  {
424 #line 6836 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
425  goto _return;
426 #line 426 OMC_FILE
427  }
428 
429 #line 429 OMC_FILE
430  { /* match expression */
431  modelica_metatype tmp4_1;
432  tmp4_1 = _e;
433  {
434  volatile mmc_switch_type tmp4;
435  int tmp5;
436  tmp4 = 0;
437  for (; tmp4 < 18; tmp4++) {
438  switch (MMC_SWITCH_CAST(tmp4)) {
439  case 0: {
440  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
441 
442  /* Pattern matching succeeded */
443 #line 6839 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
444  tmp1 = 1;
445 #line 445 OMC_FILE
446  goto tmp3_done;
447  }
448  case 1: {
449  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
450 
451  /* Pattern matching succeeded */
452 #line 6840 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
453  tmp1 = 1;
454 #line 454 OMC_FILE
455  goto tmp3_done;
456  }
457  case 2: {
458  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,1) == 0) goto tmp3_end;
459 
460  /* Pattern matching succeeded */
461 #line 6841 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
462  tmp1 = 1;
463 #line 463 OMC_FILE
464  goto tmp3_done;
465  }
466  case 3: {
467  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,1) == 0) goto tmp3_end;
468 
469  /* Pattern matching succeeded */
470 #line 6842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
471  tmp1 = 1;
472 #line 472 OMC_FILE
473  goto tmp3_done;
474  }
475  case 4: {
476  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,3) == 0) goto tmp3_end;
477 
478  /* Pattern matching succeeded */
479 #line 6843 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
480  tmp1 = 1;
481 #line 481 OMC_FILE
482  goto tmp3_done;
483  }
484  case 5: {
485  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
486 
487  /* Pattern matching succeeded */
488 #line 6844 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
489  tmp1 = 1;
490 #line 490 OMC_FILE
491  goto tmp3_done;
492  }
493  case 6: {
494  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,3) == 0) goto tmp3_end;
495 
496  /* Pattern matching succeeded */
497 #line 6845 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
498  tmp1 = 1;
499 #line 499 OMC_FILE
500  goto tmp3_done;
501  }
502  case 7: {
503  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,2) == 0) goto tmp3_end;
504 
505  /* Pattern matching succeeded */
506 #line 6846 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
507  tmp1 = 1;
508 #line 508 OMC_FILE
509  goto tmp3_done;
510  }
511  case 8: {
512  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,3) == 0) goto tmp3_end;
513 
514  /* Pattern matching succeeded */
515 #line 6847 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
516  tmp1 = 1;
517 #line 517 OMC_FILE
518  goto tmp3_done;
519  }
520  case 9: {
521  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,10,4) == 0) goto tmp3_end;
522 
523  /* Pattern matching succeeded */
524 #line 6848 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
525  tmp1 = 1;
526 #line 526 OMC_FILE
527  goto tmp3_done;
528  }
529  case 10: {
530  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
531  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
532  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
533 
534  /* Pattern matching succeeded */
535 #line 6850 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
536  tmp1 = 1;
537 #line 537 OMC_FILE
538  goto tmp3_done;
539  }
540  case 11: {
541  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,12,2) == 0) goto tmp3_end;
542  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
543  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
544 
545  /* Pattern matching succeeded */
546 #line 6851 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
547  tmp1 = 1;
548 #line 548 OMC_FILE
549  goto tmp3_done;
550  }
551  case 12: {
552  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,13,1) == 0) goto tmp3_end;
553 
554  /* Pattern matching succeeded */
555 #line 6852 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
556  tmp1 = 1;
557 #line 557 OMC_FILE
558  goto tmp3_done;
559  }
560  case 13: {
561  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,14,1) == 0) goto tmp3_end;
562 
563  /* Pattern matching succeeded */
564 #line 6853 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
565  tmp1 = 1;
566 #line 566 OMC_FILE
567  goto tmp3_done;
568  }
569  case 14: {
570  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,15,3) == 0) goto tmp3_end;
571 
572  /* Pattern matching succeeded */
573 #line 6854 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
574  tmp1 = 1;
575 #line 575 OMC_FILE
576  goto tmp3_done;
577  }
578  case 15: {
579  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,20,2) == 0) goto tmp3_end;
580 
581  /* Pattern matching succeeded */
582 #line 6855 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
583  tmp1 = 1;
584 #line 584 OMC_FILE
585  goto tmp3_done;
586  }
587  case 16: {
588  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,22,1) == 0) goto tmp3_end;
589 
590  /* Pattern matching succeeded */
591 #line 6856 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
592  tmp1 = 1;
593 #line 593 OMC_FILE
594  goto tmp3_done;
595  }
596  case 17: {
597 
598  /* Pattern matching succeeded */
599 #line 6857 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
600  tmp1 = 0;
601 #line 601 OMC_FILE
602  goto tmp3_done;
603  }
604  }
605  goto tmp3_end;
606  tmp3_end: ;
607  }
608  goto goto_2;
609  goto_2:;
610  MMC_THROW_INTERNAL();
611  goto tmp3_done;
612  tmp3_done:;
613  }
614  }
615  _b = tmp1;
616  _return: OMC_LABEL_UNUSED
617  if (out_b) { *out_b = _b; }
618  return _e;
619 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isModificationOfPath()

DLLExport modelica_boolean omc_Absyn_isModificationOfPath ( threadData_t threadData,
modelica_metatype  _mod,
modelica_metatype  _path 
)

Definition at line 4579 of file Absyn.c.

4580 {
4581  modelica_boolean _yes;
4582  modelica_boolean tmp1 = 0;
4583  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
4584  MMC_SO();
4585  _tailrecursive: OMC_LABEL_UNUSED
4586 #line 4586 OMC_FILE
4587  { /* match expression */
4588  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
4589  tmp4_1 = _mod;
4590  tmp4_2 = _path;
4591  {
4592  modelica_string _id1 = NULL;
4593  modelica_string _id2 = NULL;
4594  volatile mmc_switch_type tmp4;
4595  int tmp5;
4596  tmp4 = 0;
4597  for (; tmp4 < 2; tmp4++) {
4598  switch (MMC_SWITCH_CAST(tmp4)) {
4599  case 0: {
4600  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
4601  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
4602  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
4603  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
4604  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,1) == 0) goto tmp3_end;
4605  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
4606 
4607  _id2 = tmpMeta[0];
4608  _id1 = tmpMeta[2];
4609  /* Pattern matching succeeded */
4610 #line 5834 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4611  tmp1 = (stringEqual(_id1, _id2));
4612 #line 4612 OMC_FILE
4613  goto tmp3_done;
4614  }
4615  case 1: {
4616 
4617  /* Pattern matching succeeded */
4618 #line 5835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4619  tmp1 = 0;
4620 #line 4620 OMC_FILE
4621  goto tmp3_done;
4622  }
4623  }
4624  goto tmp3_end;
4625  tmp3_end: ;
4626  }
4627  goto goto_2;
4628  goto_2:;
4629  MMC_THROW_INTERNAL();
4630  goto tmp3_done;
4631  tmp3_done:;
4632  }
4633  }
4634  _yes = tmp1;
4635  _return: OMC_LABEL_UNUSED
4636  return _yes;
4637 }
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_isNotInnerOuter()

DLLExport modelica_boolean omc_Absyn_isNotInnerOuter ( threadData_t threadData,
modelica_metatype  _inIO 
)

Definition at line 8473 of file Absyn.c.

8474 {
8475  modelica_boolean _outIsNotInnerOuter;
8476  modelica_boolean tmp1 = 0;
8477  MMC_SO();
8478  _tailrecursive: OMC_LABEL_UNUSED
8479 #line 8479 OMC_FILE
8480  { /* match expression */
8481  modelica_metatype tmp4_1;
8482  tmp4_1 = _inIO;
8483  {
8484  volatile mmc_switch_type tmp4;
8485  int tmp5;
8486  tmp4 = 0;
8487  for (; tmp4 < 2; tmp4++) {
8488  switch (MMC_SWITCH_CAST(tmp4)) {
8489  case 0: {
8490  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
8491  /* Pattern matching succeeded */
8492 #line 4894 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8493  tmp1 = 1;
8494 #line 8494 OMC_FILE
8495  goto tmp3_done;
8496  }
8497  case 1: {
8498 
8499  /* Pattern matching succeeded */
8500 #line 4895 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8501  tmp1 = 0;
8502 #line 8502 OMC_FILE
8503  goto tmp3_done;
8504  }
8505  }
8506  goto tmp3_end;
8507  tmp3_end: ;
8508  }
8509  goto goto_2;
8510  goto_2:;
8511  MMC_THROW_INTERNAL();
8512  goto tmp3_done;
8513  tmp3_done:;
8514  }
8515  }
8516  _outIsNotInnerOuter = tmp1;
8517  _return: OMC_LABEL_UNUSED
8518  return _outIsNotInnerOuter;
8519 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isOnlyInner()

DLLExport modelica_boolean omc_Absyn_isOnlyInner ( threadData_t threadData,
modelica_metatype  _inIO 
)

Definition at line 8644 of file Absyn.c.

8645 {
8646  modelica_boolean _outOnlyInner;
8647  modelica_boolean tmp1 = 0;
8648  MMC_SO();
8649  _tailrecursive: OMC_LABEL_UNUSED
8650 #line 8650 OMC_FILE
8651  { /* match expression */
8652  modelica_metatype tmp4_1;
8653  tmp4_1 = _inIO;
8654  {
8655  volatile mmc_switch_type tmp4;
8656  int tmp5;
8657  tmp4 = 0;
8658  for (; tmp4 < 2; tmp4++) {
8659  switch (MMC_SWITCH_CAST(tmp4)) {
8660  case 0: {
8661  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
8662  /* Pattern matching succeeded */
8663 #line 4863 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8664  tmp1 = 1;
8665 #line 8665 OMC_FILE
8666  goto tmp3_done;
8667  }
8668  case 1: {
8669 
8670  /* Pattern matching succeeded */
8671 #line 4864 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8672  tmp1 = 0;
8673 #line 8673 OMC_FILE
8674  goto tmp3_done;
8675  }
8676  }
8677  goto tmp3_end;
8678  tmp3_end: ;
8679  }
8680  goto goto_2;
8681  goto_2:;
8682  MMC_THROW_INTERNAL();
8683  goto tmp3_done;
8684  tmp3_done:;
8685  }
8686  }
8687  _outOnlyInner = tmp1;
8688  _return: OMC_LABEL_UNUSED
8689  return _outOnlyInner;
8690 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isOnlyOuter()

DLLExport modelica_boolean omc_Absyn_isOnlyOuter ( threadData_t threadData,
modelica_metatype  _inIO 
)

Definition at line 8587 of file Absyn.c.

8588 {
8589  modelica_boolean _outOnlyOuter;
8590  modelica_boolean tmp1 = 0;
8591  MMC_SO();
8592  _tailrecursive: OMC_LABEL_UNUSED
8593 #line 8593 OMC_FILE
8594  { /* match expression */
8595  modelica_metatype tmp4_1;
8596  tmp4_1 = _inIO;
8597  {
8598  volatile mmc_switch_type tmp4;
8599  int tmp5;
8600  tmp4 = 0;
8601  for (; tmp4 < 2; tmp4++) {
8602  switch (MMC_SWITCH_CAST(tmp4)) {
8603  case 0: {
8604  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
8605  /* Pattern matching succeeded */
8606 #line 4874 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8607  tmp1 = 1;
8608 #line 8608 OMC_FILE
8609  goto tmp3_done;
8610  }
8611  case 1: {
8612 
8613  /* Pattern matching succeeded */
8614 #line 4875 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8615  tmp1 = 0;
8616 #line 8616 OMC_FILE
8617  goto tmp3_done;
8618  }
8619  }
8620  goto tmp3_end;
8621  tmp3_end: ;
8622  }
8623  goto goto_2;
8624  goto_2:;
8625  MMC_THROW_INTERNAL();
8626  goto tmp3_done;
8627  tmp3_done:;
8628  }
8629  }
8630  _outOnlyOuter = tmp1;
8631  _return: OMC_LABEL_UNUSED
8632  return _outOnlyOuter;
8633 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isOuter()

DLLExport modelica_boolean omc_Absyn_isOuter ( threadData_t threadData,
modelica_metatype  _io 
)

Definition at line 8765 of file Absyn.c.

8766 {
8767  modelica_boolean _isItAnOuter;
8768  modelica_boolean tmp1 = 0;
8769  MMC_SO();
8770  _tailrecursive: OMC_LABEL_UNUSED
8771 #line 8771 OMC_FILE
8772  { /* match expression */
8773  modelica_metatype tmp4_1;
8774  tmp4_1 = _io;
8775  {
8776  int tmp4;
8777  {
8778  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
8779  case 5: {
8780 
8781  /* Pattern matching succeeded */
8782 #line 4837 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8783  tmp1 = 1;
8784 #line 8784 OMC_FILE
8785  goto tmp3_done;
8786  }
8787  case 4: {
8788 
8789  /* Pattern matching succeeded */
8790 #line 4838 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8791  tmp1 = 1;
8792 #line 8792 OMC_FILE
8793  goto tmp3_done;
8794  }
8795  default:
8796  tmp3_default: OMC_LABEL_UNUSED; {
8797 
8798  /* Pattern matching succeeded */
8799 #line 4839 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8800  tmp1 = 0;
8801 #line 8801 OMC_FILE
8802  goto tmp3_done;
8803  }
8804  }
8805  goto tmp3_end;
8806  tmp3_end: ;
8807  }
8808  goto goto_2;
8809  goto_2:;
8810  MMC_THROW_INTERNAL();
8811  goto tmp3_done;
8812  tmp3_done:;
8813  }
8814  }
8815  _isItAnOuter = tmp1;
8816  _return: OMC_LABEL_UNUSED
8817  return _isItAnOuter;
8818 }
signed char modelica_boolean
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isOutput()

DLLExport modelica_boolean omc_Absyn_isOutput ( threadData_t threadData,
modelica_metatype  _inDirection 
)

Definition at line 6213 of file Absyn.c.

6214 {
6215  modelica_boolean _outIsOutput;
6216  modelica_boolean tmp1 = 0;
6217  MMC_SO();
6218  _tailrecursive: OMC_LABEL_UNUSED
6219 #line 6219 OMC_FILE
6220  { /* match expression */
6221  modelica_metatype tmp4_1;
6222  tmp4_1 = _inDirection;
6223  {
6224  int tmp4;
6225  {
6226  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
6227  case 4: {
6228 
6229  /* Pattern matching succeeded */
6230 #line 5439 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6231  tmp1 = 1;
6232 #line 6232 OMC_FILE
6233  goto tmp3_done;
6234  }
6235  case 6: {
6236 
6237  /* Pattern matching succeeded */
6238 #line 5440 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6239  tmp1 = 1;
6240 #line 6240 OMC_FILE
6241  goto tmp3_done;
6242  }
6243  default:
6244  tmp3_default: OMC_LABEL_UNUSED; {
6245 
6246  /* Pattern matching succeeded */
6247 #line 5441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6248  tmp1 = 0;
6249 #line 6249 OMC_FILE
6250  goto tmp3_done;
6251  }
6252  }
6253  goto tmp3_end;
6254  tmp3_end: ;
6255  }
6256  goto goto_2;
6257  goto_2:;
6258  MMC_THROW_INTERNAL();
6259  goto tmp3_done;
6260  tmp3_done:;
6261  }
6262  }
6263  _outIsOutput = tmp1;
6264  _return: OMC_LABEL_UNUSED
6265  return _outIsOutput;
6266 }
signed char modelica_boolean
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isPackageRestriction()

DLLExport modelica_boolean omc_Absyn_isPackageRestriction ( threadData_t threadData,
modelica_metatype  _inRestriction 
)

Definition at line 9645 of file Absyn.c.

9646 {
9647  modelica_boolean _outIsPackage;
9648  modelica_boolean tmp1 = 0;
9649  MMC_SO();
9650  _tailrecursive: OMC_LABEL_UNUSED
9651 #line 9651 OMC_FILE
9652  { /* match expression */
9653  modelica_metatype tmp4_1;
9654  tmp4_1 = _inRestriction;
9655  {
9656  volatile mmc_switch_type tmp4;
9657  int tmp5;
9658  tmp4 = 0;
9659  for (; tmp4 < 2; tmp4++) {
9660  switch (MMC_SWITCH_CAST(tmp4)) {
9661  case 0: {
9662  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,0) == 0) goto tmp3_end;
9663  /* Pattern matching succeeded */
9664 #line 4605 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9665  tmp1 = 1;
9666 #line 9666 OMC_FILE
9667  goto tmp3_done;
9668  }
9669  case 1: {
9670 
9671  /* Pattern matching succeeded */
9672 #line 4606 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9673  tmp1 = 0;
9674 #line 9674 OMC_FILE
9675  goto tmp3_done;
9676  }
9677  }
9678  goto tmp3_end;
9679  tmp3_end: ;
9680  }
9681  goto goto_2;
9682  goto_2:;
9683  MMC_THROW_INTERNAL();
9684  goto tmp3_done;
9685  tmp3_done:;
9686  }
9687  }
9688  _outIsPackage = tmp1;
9689  _return: OMC_LABEL_UNUSED
9690  return _outIsPackage;
9691 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isParts()

DLLExport modelica_boolean omc_Absyn_isParts ( threadData_t threadData,
modelica_metatype  _cl 
)

Definition at line 5413 of file Absyn.c.

5414 {
5415  modelica_boolean _b;
5416  modelica_boolean tmp1 = 0;
5417  MMC_SO();
5418  _tailrecursive: OMC_LABEL_UNUSED
5419 #line 5419 OMC_FILE
5420  { /* match expression */
5421  modelica_metatype tmp4_1;
5422  tmp4_1 = _cl;
5423  {
5424  volatile mmc_switch_type tmp4;
5425  int tmp5;
5426  tmp4 = 0;
5427  for (; tmp4 < 2; tmp4++) {
5428  switch (MMC_SWITCH_CAST(tmp4)) {
5429  case 0: {
5430  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,5) == 0) goto tmp3_end;
5431 
5432  /* Pattern matching succeeded */
5433 #line 5614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5434  tmp1 = 1;
5435 #line 5435 OMC_FILE
5436  goto tmp3_done;
5437  }
5438  case 1: {
5439 
5440  /* Pattern matching succeeded */
5441 #line 5615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5442  tmp1 = 0;
5443 #line 5443 OMC_FILE
5444  goto tmp3_done;
5445  }
5446  }
5447  goto tmp3_end;
5448  tmp3_end: ;
5449  }
5450  goto goto_2;
5451  goto_2:;
5452  MMC_THROW_INTERNAL();
5453  goto tmp3_done;
5454  tmp3_done:;
5455  }
5456  }
5457  _b = tmp1;
5458  _return: OMC_LABEL_UNUSED
5459  return _b;
5460 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_isTuple()

DLLExport modelica_boolean omc_Absyn_isTuple ( threadData_t threadData,
modelica_metatype  _inExp 
)

Definition at line 6749 of file Absyn.c.

6750 {
6751  modelica_boolean _outIsTuple;
6752  modelica_boolean tmp1 = 0;
6753  MMC_SO();
6754  _tailrecursive: OMC_LABEL_UNUSED
6755 #line 6755 OMC_FILE
6756  { /* match expression */
6757  modelica_metatype tmp4_1;
6758  tmp4_1 = _inExp;
6759  {
6760  volatile mmc_switch_type tmp4;
6761  int tmp5;
6762  tmp4 = 0;
6763  for (; tmp4 < 2; tmp4++) {
6764  switch (MMC_SWITCH_CAST(tmp4)) {
6765  case 0: {
6766  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,16,1) == 0) goto tmp3_end;
6767 
6768  /* Pattern matching succeeded */
6769 #line 5320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6770  tmp1 = 1;
6771 #line 6771 OMC_FILE
6772  goto tmp3_done;
6773  }
6774  case 1: {
6775 
6776  /* Pattern matching succeeded */
6777 #line 5321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6778  tmp1 = 0;
6779 #line 6779 OMC_FILE
6780  goto tmp3_done;
6781  }
6782  }
6783  goto tmp3_end;
6784  tmp3_end: ;
6785  }
6786  goto goto_2;
6787  goto_2:;
6788  MMC_THROW_INTERNAL();
6789  goto tmp3_done;
6790  tmp3_done:;
6791  }
6792  }
6793  _outIsTuple = tmp1;
6794  _return: OMC_LABEL_UNUSED
6795  return _outIsTuple;
6796 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_iteratorGuard()

DLLExport modelica_metatype omc_Absyn_iteratorGuard ( threadData_t threadData,
modelica_metatype  _iterator 
)

Definition at line 13027 of file Absyn.c.

13028 {
13029  modelica_metatype _guardExp = NULL;
13030  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
13031  MMC_SO();
13032  _tailrecursive: OMC_LABEL_UNUSED
13033 #line 3749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13034  /* Pattern-matching assignment */
13035 #line 3749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13036  tmpMeta[0] = _iterator;
13037 #line 3749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13038  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
13039 #line 3749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13040  _guardExp = tmpMeta[1];
13041 #line 13041 OMC_FILE
13042  _return: OMC_LABEL_UNUSED
13043  return _guardExp;
13044 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_iteratorIndexedCrefsEqual()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_iteratorIndexedCrefsEqual ( threadData_t threadData,
modelica_metatype  _inCref1,
modelica_metatype  _inCref2 
)

Definition at line 9189 of file Absyn.c.

9190 {
9191  modelica_boolean _outEqual;
9192  modelica_metatype _cr1 = NULL;
9193  modelica_metatype _cr2 = NULL;
9194  modelica_integer _idx1;
9195  modelica_integer _idx2;
9196  modelica_integer tmp1;
9197  modelica_integer tmp2;
9198  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
9199  MMC_SO();
9200  _tailrecursive: OMC_LABEL_UNUSED
9201 #line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9202  /* Pattern-matching assignment */
9203 #line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9204  tmpMeta[0] = _inCref1;
9205 #line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9206  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
9207 #line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9208  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
9209 #line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9210  tmp1 = mmc_unbox_integer(tmpMeta[2]);
9211 #line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9212  _cr1 = tmpMeta[1];
9213 #line 4730 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9214  _idx1 = tmp1 /* pattern as ty=Integer */;
9215 #line 9215 OMC_FILE
9216 
9217 #line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9218  /* Pattern-matching assignment */
9219 #line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9220  tmpMeta[0] = _inCref2;
9221 #line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9222  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
9223 #line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9224  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
9225 #line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9226  tmp2 = mmc_unbox_integer(tmpMeta[2]);
9227 #line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9228  _cr2 = tmpMeta[1];
9229 #line 4731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9230  _idx2 = tmp2 /* pattern as ty=Integer */;
9231 #line 9231 OMC_FILE
9232 
9233 #line 4732 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9234  _outEqual = (((modelica_integer)_idx1 == (modelica_integer)_idx2) && omc_Absyn_crefEqual(threadData, _cr1, _cr2));
9235 #line 9235 OMC_FILE
9236  _return: OMC_LABEL_UNUSED
9237  return _outEqual;
9238 }
m_integer modelica_integer
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_crefEqual(threadData_t *threadData, modelica_metatype _iCr1, modelica_metatype _iCr2)
Definition: Absyn.c:9953
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_iteratorName()

DLLExport modelica_string omc_Absyn_iteratorName ( threadData_t threadData,
modelica_metatype  _iterator 
)

Definition at line 13067 of file Absyn.c.

13068 {
13069  modelica_string _name = NULL;
13070  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
13071  MMC_SO();
13072  _tailrecursive: OMC_LABEL_UNUSED
13073 #line 3735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13074  /* Pattern-matching assignment */
13075 #line 3735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13076  tmpMeta[0] = _iterator;
13077 #line 3735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13078  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
13079 #line 3735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13080  _name = tmpMeta[1];
13081 #line 13081 OMC_FILE
13082  _return: OMC_LABEL_UNUSED
13083  return _name;
13084 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_iteratorRange()

DLLExport modelica_metatype omc_Absyn_iteratorRange ( threadData_t threadData,
modelica_metatype  _iterator 
)

Definition at line 13047 of file Absyn.c.

13048 {
13049  modelica_metatype _range = NULL;
13050  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
13051  MMC_SO();
13052  _tailrecursive: OMC_LABEL_UNUSED
13053 #line 3742 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13054  /* Pattern-matching assignment */
13055 #line 3742 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13056  tmpMeta[0] = _iterator;
13057 #line 3742 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13058  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
13059 #line 3742 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13060  _range = tmpMeta[1];
13061 #line 13061 OMC_FILE
13062  _return: OMC_LABEL_UNUSED
13063  return _range;
13064 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_joinCrefs()

DLLExport modelica_metatype omc_Absyn_joinCrefs ( threadData_t threadData,
modelica_metatype  _inComponentRef1,
modelica_metatype  _inComponentRef2 
)

Definition at line 10901 of file Absyn.c.

10902 {
10903  modelica_metatype _outComponentRef = NULL;
10904  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
10905  MMC_SO();
10906  _tailrecursive: OMC_LABEL_UNUSED
10907 #line 10907 OMC_FILE
10908  { /* match expression */
10909  modelica_metatype tmp3_1;modelica_metatype tmp3_2;
10910  tmp3_1 = _inComponentRef1;
10911  tmp3_2 = _inComponentRef2;
10912  {
10913  modelica_string _id = NULL;
10914  modelica_metatype _sub = NULL;
10915  modelica_metatype _cr2 = NULL;
10916  modelica_metatype _cr_1 = NULL;
10917  modelica_metatype _cr = NULL;
10918  int tmp3;
10919  {
10920  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
10921  case 5: {
10922  modelica_boolean tmp4;
10923  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
10924  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
10925  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
10926 
10927  _id = tmpMeta[1];
10928  _sub = tmpMeta[2];
10929  _cr2 = tmp3_2;
10930  /* Pattern matching succeeded */
10931 #line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10932  tmp4 = 0; /* begin failure */
10933 #line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10934  MMC_TRY_INTERNAL(mmc_jumper)
10935 #line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10936  /* Pattern-matching assignment */
10937 #line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10938  tmpMeta[1] = _cr2;
10939 #line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10940  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,1) == 0) goto goto_5;
10941 #line 4321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10942 
10943 #line 10943 OMC_FILE
10944  tmp4 = 1;
10945  goto goto_5;
10946  goto_5:;
10947  MMC_CATCH_INTERNAL(mmc_jumper)
10948  if (tmp4) {goto goto_1;} /* end failure */
10949 #line 4322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10950  tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _sub, _cr2);
10951 #line 4322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10952  tmpMeta[0] = tmpMeta[1];
10953 #line 10953 OMC_FILE
10954  goto tmp2_done;
10955  }
10956  case 4: {
10957  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
10958  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
10959  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
10960  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
10961 
10962  _id = tmpMeta[1];
10963  _sub = tmpMeta[2];
10964  _cr = tmpMeta[3];
10965  _cr2 = tmp3_2;
10966  /* Pattern matching succeeded */
10967 #line 4325 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10968  _cr_1 = omc_Absyn_joinCrefs(threadData, _cr, _cr2);
10969 #line 10969 OMC_FILE
10970 #line 4326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10971  tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _id, _sub, _cr_1);
10972 #line 4326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10973  tmpMeta[0] = tmpMeta[1];
10974 #line 10974 OMC_FILE
10975  goto tmp2_done;
10976  }
10977  case 3: {
10978  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
10979  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
10980 
10981  _cr = tmpMeta[1];
10982  _cr2 = tmp3_2;
10983  /* Pattern matching succeeded */
10984 #line 4330 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10985  _cr_1 = omc_Absyn_joinCrefs(threadData, _cr, _cr2);
10986 #line 10986 OMC_FILE
10987 #line 4331 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10988  tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _cr_1);
10989 #line 10989 OMC_FILE
10990  goto tmp2_done;
10991  }
10992  }
10993  goto tmp2_end;
10994  tmp2_end: ;
10995  }
10996  goto goto_1;
10997  goto_1:;
10998  MMC_THROW_INTERNAL();
10999  goto tmp2_done;
11000  tmp2_done:;
11001  }
11002  }
11003  _outComponentRef = tmpMeta[0];
11004  _return: OMC_LABEL_UNUSED
11005  return _outComponentRef;
11006 }
modelica_metatype modelica_string
signed char modelica_boolean
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
DLLExport modelica_metatype omc_Absyn_joinCrefs(threadData_t *threadData, modelica_metatype _inComponentRef1, modelica_metatype _inComponentRef2)
Definition: Absyn.c:10901
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_joinPaths()

DLLExport modelica_metatype omc_Absyn_joinPaths ( threadData_t threadData,
modelica_metatype  _inPath1,
modelica_metatype  _inPath2 
)

Definition at line 12781 of file Absyn.c.

12782 {
12783  modelica_metatype _outPath = NULL;
12784  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
12785  MMC_SO();
12786  _tailrecursive: OMC_LABEL_UNUSED
12787 #line 12787 OMC_FILE
12788  { /* match expression */
12789  modelica_metatype tmp3_1;modelica_metatype tmp3_2;
12790  tmp3_1 = _inPath1;
12791  tmp3_2 = _inPath2;
12792  {
12793  modelica_string _str = NULL;
12794  modelica_metatype _p2 = NULL;
12795  modelica_metatype _p_1 = NULL;
12796  modelica_metatype _p = NULL;
12797  int tmp3;
12798  {
12799  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
12800  case 4: {
12801  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
12802  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12803 
12804  _str = tmpMeta[1];
12805  _p2 = tmp3_2;
12806  /* Pattern matching succeeded */
12807 #line 3804 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12808  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _str, _p2);
12809 #line 3804 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12810  tmpMeta[0] = tmpMeta[1];
12811 #line 12811 OMC_FILE
12812  goto tmp2_done;
12813  }
12814  case 3: {
12815  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
12816  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12817  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12818 
12819  _str = tmpMeta[1];
12820  _p = tmpMeta[2];
12821  _p2 = tmp3_2;
12822  /* Pattern matching succeeded */
12823 #line 3807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12824  _p_1 = omc_Absyn_joinPaths(threadData, _p, _p2);
12825 #line 12825 OMC_FILE
12826 #line 3808 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12827  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _str, _p_1);
12828 #line 3808 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12829  tmpMeta[0] = tmpMeta[1];
12830 #line 12830 OMC_FILE
12831  goto tmp2_done;
12832  }
12833  case 5: {
12834  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
12835  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12836 
12837  _p = tmpMeta[1];
12838  _p2 = tmp3_2;
12839  /* Pattern matching succeeded */
12840 #line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12841  /* Tail recursive call */
12842 #line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12843  _inPath1 = _p;
12844 #line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12845  _inPath2 = _p2;
12846 #line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12847  goto _tailrecursive;
12848 #line 3810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12849  /* TODO: Make sure any eventual dead code below is never generated */
12850 #line 12850 OMC_FILE
12851  goto tmp2_done;
12852  }
12853  default:
12854  tmp2_default: OMC_LABEL_UNUSED; {
12855  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,2,1) == 0) goto tmp2_end;
12856  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
12857 
12858  _p2 = tmpMeta[1];
12859  _p = tmp3_1;
12860  /* Pattern matching succeeded */
12861 #line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12862  /* Tail recursive call */
12863 #line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12864  _inPath1 = _p;
12865 #line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12866  _inPath2 = _p2;
12867 #line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12868  goto _tailrecursive;
12869 #line 3811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12870  /* TODO: Make sure any eventual dead code below is never generated */
12871 #line 12871 OMC_FILE
12872  goto tmp2_done;
12873  }
12874  }
12875  goto tmp2_end;
12876  tmp2_end: ;
12877  }
12878  goto goto_1;
12879  goto_1:;
12880  MMC_THROW_INTERNAL();
12881  goto tmp2_done;
12882  tmp2_done:;
12883  }
12884  }
12885  _outPath = tmpMeta[0];
12886  _return: OMC_LABEL_UNUSED
12887  return _outPath;
12888 }
modelica_metatype modelica_string
DLLExport modelica_metatype omc_Absyn_joinPaths(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:12781
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_joinPathsOpt()

DLLExport modelica_metatype omc_Absyn_joinPathsOpt ( threadData_t threadData,
modelica_metatype  _inPath1,
modelica_metatype  _inPath2 
)

Definition at line 12729 of file Absyn.c.

12730 {
12731  modelica_metatype _outPath = NULL;
12732  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
12733  MMC_SO();
12734  _tailrecursive: OMC_LABEL_UNUSED
12735 #line 12735 OMC_FILE
12736  { /* match expression */
12737  modelica_metatype tmp3_1;
12738  tmp3_1 = _inPath1;
12739  {
12740  modelica_metatype _p = NULL;
12741  volatile mmc_switch_type tmp3;
12742  int tmp4;
12743  tmp3 = 0;
12744  for (; tmp3 < 2; tmp3++) {
12745  switch (MMC_SWITCH_CAST(tmp3)) {
12746  case 0: {
12747  if (!optionNone(tmp3_1)) goto tmp2_end;
12748  /* Pattern matching succeeded */
12749 #line 3822 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12750  tmpMeta[0] = _inPath2;
12751 #line 12751 OMC_FILE
12752  goto tmp2_done;
12753  }
12754  case 1: {
12755  if (optionNone(tmp3_1)) goto tmp2_end;
12756  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
12757  _p = tmpMeta[1];
12758  /* Pattern matching succeeded */
12759 #line 3823 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12760  tmpMeta[0] = omc_Absyn_joinPaths(threadData, _p, _inPath2);
12761 #line 12761 OMC_FILE
12762  goto tmp2_done;
12763  }
12764  }
12765  goto tmp2_end;
12766  tmp2_end: ;
12767  }
12768  goto goto_1;
12769  goto_1:;
12770  MMC_THROW_INTERNAL();
12771  goto tmp2_done;
12772  tmp2_done:;
12773  }
12774  }
12775  _outPath = tmpMeta[0];
12776  _return: OMC_LABEL_UNUSED
12777  return _outPath;
12778 }
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_joinPaths(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:12781
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_joinPathsOptSuffix()

DLLExport modelica_metatype omc_Absyn_joinPathsOptSuffix ( threadData_t threadData,
modelica_metatype  _inPath1,
modelica_metatype  _inPath2 
)

Definition at line 12677 of file Absyn.c.

12678 {
12679  modelica_metatype _outPath = NULL;
12680  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
12681  MMC_SO();
12682  _tailrecursive: OMC_LABEL_UNUSED
12683 #line 12683 OMC_FILE
12684  { /* match expression */
12685  modelica_metatype tmp3_1;
12686  tmp3_1 = _inPath2;
12687  {
12688  modelica_metatype _p = NULL;
12689  volatile mmc_switch_type tmp3;
12690  int tmp4;
12691  tmp3 = 0;
12692  for (; tmp3 < 2; tmp3++) {
12693  switch (MMC_SWITCH_CAST(tmp3)) {
12694  case 0: {
12695  if (optionNone(tmp3_1)) goto tmp2_end;
12696  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
12697  _p = tmpMeta[1];
12698  /* Pattern matching succeeded */
12699 #line 3836 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12700  tmpMeta[0] = omc_Absyn_joinPaths(threadData, _inPath1, _p);
12701 #line 12701 OMC_FILE
12702  goto tmp2_done;
12703  }
12704  case 1: {
12705 
12706  /* Pattern matching succeeded */
12707 #line 3837 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12708  tmpMeta[0] = _inPath1;
12709 #line 12709 OMC_FILE
12710  goto tmp2_done;
12711  }
12712  }
12713  goto tmp2_end;
12714  tmp2_end: ;
12715  }
12716  goto goto_1;
12717  goto_1:;
12718  MMC_THROW_INTERNAL();
12719  goto tmp2_done;
12720  tmp2_done:;
12721  }
12722  }
12723  _outPath = tmpMeta[0];
12724  _return: OMC_LABEL_UNUSED
12725  return _outPath;
12726 }
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_joinPaths(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:12781
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_joinWithinPath()

DLLExport modelica_metatype omc_Absyn_joinWithinPath ( threadData_t threadData,
modelica_metatype  _within_,
modelica_metatype  _path 
)

Definition at line 7176 of file Absyn.c.

7177 {
7178  modelica_metatype _outPath = NULL;
7179  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
7180  MMC_SO();
7181  _tailrecursive: OMC_LABEL_UNUSED
7182 #line 7182 OMC_FILE
7183  { /* match expression */
7184  modelica_metatype tmp3_1;
7185  tmp3_1 = _within_;
7186  {
7187  modelica_metatype _path1 = NULL;
7188  volatile mmc_switch_type tmp3;
7189  int tmp4;
7190  tmp3 = 0;
7191  for (; tmp3 < 2; tmp3++) {
7192  switch (MMC_SWITCH_CAST(tmp3)) {
7193  case 0: {
7194  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,0) == 0) goto tmp2_end;
7195  /* Pattern matching succeeded */
7196 #line 5226 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7197  tmpMeta[0] = _path;
7198 #line 7198 OMC_FILE
7199  goto tmp2_done;
7200  }
7201  case 1: {
7202  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
7203  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
7204  _path1 = tmpMeta[1];
7205  /* Pattern matching succeeded */
7206 #line 5227 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7207  tmpMeta[0] = omc_Absyn_joinPaths(threadData, _path1, _path);
7208 #line 7208 OMC_FILE
7209  goto tmp2_done;
7210  }
7211  }
7212  goto tmp2_end;
7213  tmp2_end: ;
7214  }
7215  goto goto_1;
7216  goto_1:;
7217  MMC_THROW_INTERNAL();
7218  goto tmp2_done;
7219  tmp2_done:;
7220  }
7221  }
7222  _outPath = tmpMeta[0];
7223  _return: OMC_LABEL_UNUSED
7224  return _outPath;
7225 }
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_joinPaths(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:12781
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_lastClassname()

DLLExport modelica_metatype omc_Absyn_lastClassname ( threadData_t threadData,
modelica_metatype  _inProgram 
)

Definition at line 10303 of file Absyn.c.

10304 {
10305  modelica_metatype _outPath = NULL;
10306  modelica_metatype _lst = NULL;
10307  modelica_string _id = NULL;
10308  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
10309  MMC_SO();
10310  _tailrecursive: OMC_LABEL_UNUSED
10311 #line 4441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10312  /* Pattern-matching assignment */
10313 #line 4441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10314  tmpMeta[0] = _inProgram;
10315 #line 4441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10316  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
10317 #line 4441 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10318  _lst = tmpMeta[1];
10319 #line 10319 OMC_FILE
10320 
10321 #line 4442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10322  /* Pattern-matching assignment */
10323 #line 4442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10324  tmpMeta[0] = omc_List_last(threadData, _lst);
10325 #line 4442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10326  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
10327 #line 4442 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10328  _id = tmpMeta[1];
10329 #line 10329 OMC_FILE
10330 
10331 #line 4443 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10332  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _id);
10333 #line 4443 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10334  _outPath = tmpMeta[0];
10335 #line 10335 OMC_FILE
10336  _return: OMC_LABEL_UNUSED
10337  return _outPath;
10338 }
modelica_metatype modelica_string
DLLExport modelica_metatype omc_List_last(threadData_t *threadData, modelica_metatype _inList)
Definition: List.c:17415
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_makeClassElement()

DLLExport modelica_metatype omc_Absyn_makeClassElement ( threadData_t threadData,
modelica_metatype  _cl 
)

Definition at line 5374 of file Absyn.c.

5375 {
5376  modelica_metatype _el = NULL;
5377  modelica_metatype _info = NULL;
5378  modelica_boolean _fp;
5379  modelica_integer tmp1;
5380  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
5381  MMC_SO();
5382  _tailrecursive: OMC_LABEL_UNUSED
5383 #line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5384  /* Pattern-matching assignment */
5385 #line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5386  tmpMeta[0] = _cl;
5387 #line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5388  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
5389 #line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5390  tmp1 = mmc_unbox_integer(tmpMeta[1]);
5391 #line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5392  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 8));
5393 #line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5394  _fp = tmp1 /* pattern as ty=Boolean */;
5395 #line 5626 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5396  _info = tmpMeta[2];
5397 #line 5397 OMC_FILE
5398 
5399 #line 5627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5400  tmpMeta[0] = mmc_mk_box3(3, &Absyn_ElementSpec_CLASSDEF__desc, mmc_mk_boolean(0), _cl);
5401 #line 5627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5402  tmpMeta[1] = mmc_mk_box7(3, &Absyn_Element_ELEMENT__desc, mmc_mk_boolean(_fp), mmc_mk_none(), _OMC_LIT7, tmpMeta[0], _info, mmc_mk_none());
5403 #line 5627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5404  tmpMeta[2] = mmc_mk_box2(3, &Absyn_ElementItem_ELEMENTITEM__desc, tmpMeta[1]);
5405 #line 5627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5406  _el = tmpMeta[2];
5407 #line 5407 OMC_FILE
5408  _return: OMC_LABEL_UNUSED
5409  return _el;
5410 }
m_integer modelica_integer
signed char modelica_boolean
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ElementItem_ELEMENTITEM__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Element_ELEMENT__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ElementSpec_CLASSDEF__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_makeCons()

DLLExport modelica_metatype omc_Absyn_makeCons ( threadData_t threadData,
modelica_metatype  _e1,
modelica_metatype  _e2 
)

Definition at line 7625 of file Absyn.c.

7626 {
7627  modelica_metatype _e = NULL;
7628  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
7629  MMC_SO();
7630  _tailrecursive: OMC_LABEL_UNUSED
7631 #line 5129 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7632  tmpMeta[0] = mmc_mk_box3(23, &Absyn_Exp_CONS__desc, _e1, _e2);
7633 #line 5129 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7634  _e = tmpMeta[0];
7635 #line 7635 OMC_FILE
7636  _return: OMC_LABEL_UNUSED
7637  return _e;
7638 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_CONS__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_makeFullyQualified()

DLLExport modelica_metatype omc_Absyn_makeFullyQualified ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 8335 of file Absyn.c.

8336 {
8337  modelica_metatype _outPath = NULL;
8338  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
8339  MMC_SO();
8340  _tailrecursive: OMC_LABEL_UNUSED
8341 #line 8341 OMC_FILE
8342  { /* match expression */
8343  modelica_metatype tmp3_1;
8344  tmp3_1 = _inPath;
8345  {
8346  volatile mmc_switch_type tmp3;
8347  int tmp4;
8348  tmp3 = 0;
8349  for (; tmp3 < 2; tmp3++) {
8350  switch (MMC_SWITCH_CAST(tmp3)) {
8351  case 0: {
8352  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
8353 
8354  /* Pattern matching succeeded */
8355 #line 4919 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8356  tmpMeta[0] = _inPath;
8357 #line 8357 OMC_FILE
8358  goto tmp2_done;
8359  }
8360  case 1: {
8361 
8362  /* Pattern matching succeeded */
8363 #line 4920 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8364  tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _inPath);
8365 #line 4920 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8366  tmpMeta[0] = tmpMeta[1];
8367 #line 8367 OMC_FILE
8368  goto tmp2_done;
8369  }
8370  }
8371  goto tmp2_end;
8372  tmp2_end: ;
8373  }
8374  goto goto_1;
8375  goto_1:;
8376  MMC_THROW_INTERNAL();
8377  goto tmp2_done;
8378  tmp2_done:;
8379  }
8380  }
8381  _outPath = tmpMeta[0];
8382  _return: OMC_LABEL_UNUSED
8383  return _outPath;
8384 }
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_FULLYQUALIFIED__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_makeIdentPathFromString()

DLLExport modelica_metatype omc_Absyn_makeIdentPathFromString ( threadData_t threadData,
modelica_string  _s 
)

Definition at line 18229 of file Absyn.c.

18230 {
18231  modelica_metatype _p = NULL;
18232  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
18233  MMC_SO();
18234  _tailrecursive: OMC_LABEL_UNUSED
18235 #line 2412 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18236  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s);
18237 #line 2412 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18238  _p = tmpMeta[0];
18239 #line 18239 OMC_FILE
18240  _return: OMC_LABEL_UNUSED
18241  return _p;
18242 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_makeNotFullyQualified()

DLLExport modelica_metatype omc_Absyn_makeNotFullyQualified ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 8283 of file Absyn.c.

8284 {
8285  modelica_metatype _outPath = NULL;
8286  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
8287  MMC_SO();
8288  _tailrecursive: OMC_LABEL_UNUSED
8289 #line 8289 OMC_FILE
8290  { /* match expression */
8291  modelica_metatype tmp3_1;
8292  tmp3_1 = _inPath;
8293  {
8294  modelica_metatype _path = NULL;
8295  volatile mmc_switch_type tmp3;
8296  int tmp4;
8297  tmp3 = 0;
8298  for (; tmp3 < 2; tmp3++) {
8299  switch (MMC_SWITCH_CAST(tmp3)) {
8300  case 0: {
8301  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
8302  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
8303  _path = tmpMeta[1];
8304  /* Pattern matching succeeded */
8305 #line 4931 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8306  tmpMeta[0] = _path;
8307 #line 8307 OMC_FILE
8308  goto tmp2_done;
8309  }
8310  case 1: {
8311 
8312  /* Pattern matching succeeded */
8313 #line 4932 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8314  tmpMeta[0] = _inPath;
8315 #line 8315 OMC_FILE
8316  goto tmp2_done;
8317  }
8318  }
8319  goto tmp2_end;
8320  tmp2_end: ;
8321  }
8322  goto goto_1;
8323  goto_1:;
8324  MMC_THROW_INTERNAL();
8325  goto tmp2_done;
8326  tmp2_done:;
8327  }
8328  }
8329  _outPath = tmpMeta[0];
8330  _return: OMC_LABEL_UNUSED
8331  return _outPath;
8332 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_makeQualifiedPathFromStrings()

DLLExport modelica_metatype omc_Absyn_makeQualifiedPathFromStrings ( threadData_t threadData,
modelica_string  _s1,
modelica_string  _s2 
)

Definition at line 18211 of file Absyn.c.

18212 {
18213  modelica_metatype _p = NULL;
18214  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
18215  MMC_SO();
18216  _tailrecursive: OMC_LABEL_UNUSED
18217 #line 2421 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18218  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s2);
18219 #line 2421 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18220  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _s1, tmpMeta[0]);
18221 #line 2421 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18222  _p = tmpMeta[1];
18223 #line 18223 OMC_FILE
18224  _return: OMC_LABEL_UNUSED
18225  return _p;
18226 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_makeSubscript()

DLLExport modelica_metatype omc_Absyn_makeSubscript ( threadData_t threadData,
modelica_metatype  _inExp 
)

Definition at line 2075 of file Absyn.c.

2076 {
2077  modelica_metatype _outSubscript = NULL;
2078  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
2079  MMC_SO();
2080  _tailrecursive: OMC_LABEL_UNUSED
2081 #line 6571 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2082  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Subscript_SUBSCRIPT__desc, _inExp);
2083 #line 6571 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2084  _outSubscript = tmpMeta[0];
2085 #line 2085 OMC_FILE
2086  _return: OMC_LABEL_UNUSED
2087  return _outSubscript;
2088 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Subscript_SUBSCRIPT__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_mapCrefParts()

DLLExport modelica_metatype omc_Absyn_mapCrefParts ( threadData_t threadData,
modelica_metatype  _inCref,
modelica_fnptr  _inMapFunc 
)

Definition at line 3462 of file Absyn.c.

3463 {
3464  modelica_metatype _outCref = NULL;
3465  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
3466  MMC_SO();
3467  _tailrecursive: OMC_LABEL_UNUSED
3468 #line 3468 OMC_FILE
3469  { /* match expression */
3470  modelica_metatype tmp3_1;
3471  tmp3_1 = _inCref;
3472  {
3473  modelica_string _name = NULL;
3474  modelica_metatype _subs = NULL;
3475  modelica_metatype _rest_cref = NULL;
3476  modelica_metatype _cref = NULL;
3477  int tmp3;
3478  {
3479  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
3480  case 4: {
3481  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
3482  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
3483  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
3484  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
3485  _name = tmpMeta[1];
3486  _subs = tmpMeta[2];
3487  _rest_cref = tmpMeta[3];
3488  /* Pattern matching succeeded */
3489 #line 6148 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3490  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _name, _subs);
3491 #line 6148 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3492  _cref = tmpMeta[1];
3493 #line 3493 OMC_FILE
3494 
3495 #line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3496  /* Pattern-matching assignment */
3497 #line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3498  tmpMeta[1] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 2))), _cref) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 1)))) (threadData, _cref);
3499 #line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3500  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto goto_1;
3501 #line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3502  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
3503 #line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3504  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
3505 #line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3506  _name = tmpMeta[2];
3507 #line 6149 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3508  _subs = tmpMeta[3];
3509 #line 3509 OMC_FILE
3510 
3511 #line 6150 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3512  _rest_cref = omc_Absyn_mapCrefParts(threadData, _rest_cref, ((modelica_fnptr) _inMapFunc));
3513 #line 3513 OMC_FILE
3514 #line 6151 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3515  tmpMeta[1] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _name, _subs, _rest_cref);
3516 #line 6151 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3517  tmpMeta[0] = tmpMeta[1];
3518 #line 3518 OMC_FILE
3519  goto tmp2_done;
3520  }
3521  case 3: {
3522  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
3523  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
3524  _cref = tmpMeta[1];
3525  /* Pattern matching succeeded */
3526 #line 6156 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3527  _cref = omc_Absyn_mapCrefParts(threadData, _cref, ((modelica_fnptr) _inMapFunc));
3528 #line 3528 OMC_FILE
3529 #line 6157 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3530  tmpMeta[1] = mmc_mk_box2(3, &Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc, _cref);
3531 #line 6157 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3532  tmpMeta[0] = tmpMeta[1];
3533 #line 3533 OMC_FILE
3534  goto tmp2_done;
3535  }
3536  default:
3537  tmp2_default: OMC_LABEL_UNUSED; {
3538 
3539  /* Pattern matching succeeded */
3540 #line 6162 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3541  tmpMeta[0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 2))), _inCref) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inMapFunc), 1)))) (threadData, _inCref);
3542 #line 3542 OMC_FILE
3543  goto tmp2_done;
3544  }
3545  }
3546  goto tmp2_end;
3547  tmp2_end: ;
3548  }
3549  goto goto_1;
3550  goto_1:;
3551  MMC_THROW_INTERNAL();
3552  goto tmp2_done;
3553  tmp2_done:;
3554  }
3555  }
3556  _outCref = tmpMeta[0];
3557  _return: OMC_LABEL_UNUSED
3558  return _outCref;
3559 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
modelica_metatype modelica_string
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_mapCrefParts(threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _inMapFunc)
Definition: Absyn.c:3462
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__FULLYQUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_mergeAnnotations()

DLLExport modelica_metatype omc_Absyn_mergeAnnotations ( threadData_t threadData,
modelica_metatype  _inAnnotation1,
modelica_metatype  _inAnnotation2 
)

Definition at line 4845 of file Absyn.c.

4846 {
4847  modelica_metatype _outAnnotation = NULL;
4848  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
4849  MMC_SO();
4850  _tailrecursive: OMC_LABEL_UNUSED
4851 #line 4851 OMC_FILE
4852  { /* match expression */
4853  modelica_metatype tmp3_1;modelica_metatype tmp3_2;
4854  tmp3_1 = _inAnnotation1;
4855  tmp3_2 = _inAnnotation2;
4856  {
4857  modelica_metatype _oldmods = NULL;
4858  modelica_metatype _newmods = NULL;
4859  modelica_metatype _a = NULL;
4860  volatile mmc_switch_type tmp3;
4861  int tmp4;
4862  tmp3 = 0;
4863  for (; tmp3 < 2; tmp3++) {
4864  switch (MMC_SWITCH_CAST(tmp3)) {
4865  case 0: {
4866  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
4867  if (!listEmpty(tmpMeta[1])) goto tmp2_end;
4868 
4869  _a = tmp3_2;
4870  /* Pattern matching succeeded */
4871 #line 5767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4872  tmpMeta[0] = _a;
4873 #line 4873 OMC_FILE
4874  goto tmp2_done;
4875  }
4876  case 1: {
4877  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
4878  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
4879  _oldmods = tmpMeta[1];
4880  _newmods = tmpMeta[2];
4881  /* Pattern matching succeeded */
4882 #line 5770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4883  tmpMeta[1] = mmc_mk_box2(3, &Absyn_Annotation_ANNOTATION__desc, omc_Absyn_mergeAnnotations2(threadData, _oldmods, _newmods));
4884 #line 5770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4885  tmpMeta[0] = tmpMeta[1];
4886 #line 4886 OMC_FILE
4887  goto tmp2_done;
4888  }
4889  }
4890  goto tmp2_end;
4891  tmp2_end: ;
4892  }
4893  goto goto_1;
4894  goto_1:;
4895  MMC_THROW_INTERNAL();
4896  goto tmp2_done;
4897  tmp2_done:;
4898  }
4899  }
4900  _outAnnotation = tmpMeta[0];
4901  _return: OMC_LABEL_UNUSED
4902  return _outAnnotation;
4903 }
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Annotation_ANNOTATION__desc
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_mergeAnnotations2(threadData_t *threadData, modelica_metatype _oldmods, modelica_metatype _newmods)
Definition: Absyn.c:4733
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_mergeAnnotations2()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_mergeAnnotations2 ( threadData_t threadData,
modelica_metatype  _oldmods,
modelica_metatype  _newmods 
)

Definition at line 4733 of file Absyn.c.

4734 {
4735  modelica_metatype _res = NULL;
4736  modelica_metatype _mods = NULL;
4737  modelica_boolean _b;
4738  modelica_metatype _p = NULL;
4739  modelica_metatype _mod1 = NULL;
4740  modelica_metatype _mod2 = NULL;
4741  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
4742  MMC_SO();
4743  _tailrecursive: OMC_LABEL_UNUSED
4744  _res = listReverse(_oldmods);
4745 #line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4746  {
4747 #line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4748  modelica_metatype _mod;
4749 #line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4750  for (tmpMeta[0] = _newmods; !listEmpty(tmpMeta[0]); tmpMeta[0]=MMC_CDR(tmpMeta[0]))
4751 #line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4752  {
4753 #line 5786 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4754  _mod = MMC_CAR(tmpMeta[0]);
4755 #line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4756  /* Pattern-matching assignment */
4757 #line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4758  tmpMeta[1] = _mod;
4759 #line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4760  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,6) == 0) MMC_THROW_INTERNAL();
4761 #line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4762  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 4));
4763 #line 5787 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4764  _p = tmpMeta[2];
4765 #line 4765 OMC_FILE
4766 
4767 #line 4767 OMC_FILE
4768  { /* matchcontinue expression */
4769  {
4770  volatile mmc_switch_type tmp3;
4771  int tmp4;
4772  tmp3 = 0;
4773  MMC_TRY_INTERNAL(mmc_jumper)
4774  tmp2_top:
4775  threadData->mmc_jumper = &new_mmc_jumper;
4776  for (; tmp3 < 2; tmp3++) {
4777  switch (MMC_SWITCH_CAST(tmp3)) {
4778  case 0: {
4779  modelica_boolean tmp5;
4780  /* Pattern matching succeeded */
4781 #line 5789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4782  tmpMeta[1] = mmc_mk_box1(0, _p);
4783 #line 5789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4784  _mod2 = omc_List_find(threadData, _res, (modelica_fnptr) mmc_mk_box2(0,closure4_Absyn_isModificationOfPath,tmpMeta[1]));
4785 #line 4785 OMC_FILE
4786 
4787 #line 5790 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4788  _mod1 = omc_Absyn_subModsInSameOrder(threadData, _mod2, _mod);
4789 #line 4789 OMC_FILE
4790 
4791 #line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4792  /* Pattern-matching tuple assignment */
4793 #line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4794  tmpMeta[1] = mmc_mk_box1(0, _p);
4795 #line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4796  tmpMeta[2] = omc_List_replaceOnTrue(threadData, _mod1, _res, (modelica_fnptr) mmc_mk_box2(0,closure5_Absyn_isModificationOfPath,tmpMeta[1]), &tmp5);
4797 #line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4798  _res = tmpMeta[2];
4799 #line 5791 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4800  if (1 != tmp5) goto goto_1;
4801 #line 4801 OMC_FILE
4802 #line 4802 OMC_FILE
4803  goto tmp2_done;
4804  }
4805  case 1: {
4806  /* Pattern matching succeeded */
4807 #line 5793 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4808  tmpMeta[1] = mmc_mk_cons(_mod, _res);
4809 #line 5793 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4810  _res = tmpMeta[1];
4811 #line 4811 OMC_FILE
4812 #line 4812 OMC_FILE
4813  goto tmp2_done;
4814  }
4815  }
4816  goto tmp2_end;
4817  tmp2_end: ;
4818  }
4819  goto goto_1;
4820  tmp2_done:
4821  (void)tmp3;
4822  MMC_RESTORE_INTERNAL(mmc_jumper);
4823  goto tmp2_done2;
4824  goto_1:;
4825  MMC_CATCH_INTERNAL(mmc_jumper);
4826  if (++tmp3 < 2) {
4827  goto tmp2_top;
4828  }
4829  MMC_THROW_INTERNAL();
4830  tmp2_done2:;
4831  }
4832  }
4833  ;
4834  }
4835  }
4836 
4837 #line 5796 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4838  _res = listReverse(_res);
4839 #line 4839 OMC_FILE
4840  _return: OMC_LABEL_UNUSED
4841  return _res;
4842 }
DLLExport modelica_metatype omc_Absyn_subModsInSameOrder(threadData_t *threadData, modelica_metatype _oldmod, modelica_metatype _newmod)
Definition: Absyn.c:4432
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
signed char modelica_boolean
float mmc_switch_type
void * modelica_fnptr
DLLExport modelica_metatype omc_List_find(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc)
Definition: List.c:3136
DLLExport modelica_metatype omc_List_replaceOnTrue(threadData_t *threadData, modelica_metatype _inReplacement, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_boolean *out_outReplaced)
Definition: List.c:2330
void * modelica_metatype
modelica_metatype listReverse(modelica_metatype)
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
int line
Definition: de.c:117
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:

◆ omc_Absyn_mergeCommentAnnotation()

DLLExport modelica_metatype omc_Absyn_mergeCommentAnnotation ( threadData_t threadData,
modelica_metatype  _inAnnotation,
modelica_metatype  _inComment 
)

Definition at line 4648 of file Absyn.c.

4649 {
4650  modelica_metatype _outComment = NULL;
4651  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
4652  MMC_SO();
4653  _tailrecursive: OMC_LABEL_UNUSED
4654 #line 4654 OMC_FILE
4655  { /* match expression */
4656  modelica_metatype tmp3_1;
4657  tmp3_1 = _inComment;
4658  {
4659  modelica_metatype _ann = NULL;
4660  modelica_metatype _cmt = NULL;
4661  volatile mmc_switch_type tmp3;
4662  int tmp4;
4663  tmp3 = 0;
4664  for (; tmp3 < 3; tmp3++) {
4665  switch (MMC_SWITCH_CAST(tmp3)) {
4666  case 0: {
4667  if (!optionNone(tmp3_1)) goto tmp2_end;
4668  /* Pattern matching succeeded */
4669 #line 5812 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4670  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Comment_COMMENT__desc, mmc_mk_some(_inAnnotation), mmc_mk_none());
4671 #line 5812 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4672  tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
4673 #line 4673 OMC_FILE
4674  goto tmp2_done;
4675  }
4676  case 1: {
4677  if (optionNone(tmp3_1)) goto tmp2_end;
4678  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
4679  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
4680  if (!optionNone(tmpMeta[2])) goto tmp2_end;
4681  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
4682  _cmt = tmpMeta[3];
4683  /* Pattern matching succeeded */
4684 #line 5816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4685  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Comment_COMMENT__desc, mmc_mk_some(_inAnnotation), _cmt);
4686 #line 5816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4687  tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
4688 #line 4688 OMC_FILE
4689  goto tmp2_done;
4690  }
4691  case 2: {
4692  if (optionNone(tmp3_1)) goto tmp2_end;
4693  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
4694  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
4695  if (optionNone(tmpMeta[2])) goto tmp2_end;
4696  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
4697  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
4698  _ann = tmpMeta[3];
4699  _cmt = tmpMeta[4];
4700  /* Pattern matching succeeded */
4701 #line 5820 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4702  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Comment_COMMENT__desc, mmc_mk_some(omc_Absyn_mergeAnnotations(threadData, _ann, _inAnnotation)), _cmt);
4703 #line 5820 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4704  tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
4705 #line 4705 OMC_FILE
4706  goto tmp2_done;
4707  }
4708  }
4709  goto tmp2_end;
4710  tmp2_end: ;
4711  }
4712  goto goto_1;
4713  goto_1:;
4714  MMC_THROW_INTERNAL();
4715  goto tmp2_done;
4716  tmp2_done:;
4717  }
4718  }
4719  _outComment = tmpMeta[0];
4720  _return: OMC_LABEL_UNUSED
4721  return _outComment;
4722 }
float mmc_switch_type
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_mergeAnnotations(threadData_t *threadData, modelica_metatype _inAnnotation1, modelica_metatype _inAnnotation2)
Definition: Absyn.c:4845
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Comment_COMMENT__desc

◆ omc_Absyn_onlyLiteralsInAnnotationMod()

DLLExport modelica_boolean omc_Absyn_onlyLiteralsInAnnotationMod ( threadData_t threadData,
modelica_metatype  _inMod 
)

Definition at line 7927 of file Absyn.c.

7928 {
7929  modelica_boolean _onlyLiterals;
7930  modelica_boolean tmp1 = 0;
7931  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
7932  MMC_SO();
7933  _tailrecursive: OMC_LABEL_UNUSED
7934 #line 7934 OMC_FILE
7935  { /* matchcontinue expression */
7936  volatile modelica_metatype tmp4_1;
7937  tmp4_1 = _inMod;
7938  {
7939  modelica_metatype _dive = NULL;
7940  modelica_metatype _rest = NULL;
7941  modelica_metatype _eqMod = NULL;
7942  modelica_boolean _b1;
7943  modelica_boolean _b2;
7944  modelica_boolean _b3;
7945  volatile mmc_switch_type tmp4;
7946  int tmp5;
7947  tmp4 = 0;
7948  MMC_TRY_INTERNAL(mmc_jumper)
7949  tmp3_top:
7950  threadData->mmc_jumper = &new_mmc_jumper;
7951  for (; tmp4 < 5; tmp4++) {
7952  switch (MMC_SWITCH_CAST(tmp4)) {
7953  case 0: {
7954  if (!listEmpty(tmp4_1)) goto tmp3_end;
7955  tmp4 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
7956 #line 4994 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7957  tmp1 = 1;
7958 #line 7958 OMC_FILE
7959  goto tmp3_done;
7960  }
7961  case 1: {
7962  if (listEmpty(tmp4_1)) goto tmp3_end;
7963  tmpMeta[0] = MMC_CAR(tmp4_1);
7964  tmpMeta[1] = MMC_CDR(tmp4_1);
7965  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,6) == 0) goto tmp3_end;
7966  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
7967  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],1,1) == 0) goto tmp3_end;
7968  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
7969  if (11 != MMC_STRLEN(tmpMeta[3]) || strcmp(MMC_STRINGDATA(_OMC_LIT31), MMC_STRINGDATA(tmpMeta[3])) != 0) goto tmp3_end;
7970 
7971  _rest = tmpMeta[1];
7972  /* Pattern matching succeeded */
7973 #line 4999 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7974  tmp1 = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _rest);
7975 #line 7975 OMC_FILE
7976  goto tmp3_done;
7977  }
7978  case 2: {
7979  if (listEmpty(tmp4_1)) goto tmp3_end;
7980  tmpMeta[0] = MMC_CAR(tmp4_1);
7981  tmpMeta[1] = MMC_CDR(tmp4_1);
7982  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,6) == 0) goto tmp3_end;
7983  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 5));
7984  if (optionNone(tmpMeta[2])) goto tmp3_end;
7985  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 1));
7986  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
7987  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 3));
7988 
7989  _dive = tmpMeta[4];
7990  _eqMod = tmpMeta[5];
7991  _rest = tmpMeta[1];
7992  /* Pattern matching succeeded */
7993 #line 5007 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7994  _b1 = omc_Absyn_onlyLiteralsInEqMod(threadData, _eqMod);
7995 #line 7995 OMC_FILE
7996 
7997 #line 5008 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7998  _b2 = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _dive);
7999 #line 7999 OMC_FILE
8000 
8001 #line 5009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8002  _b3 = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _rest);
8003 #line 8003 OMC_FILE
8004 #line 5010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8005  tmp1 = (_b1 && (_b2 && _b3));
8006 #line 8006 OMC_FILE
8007  goto tmp3_done;
8008  }
8009  case 3: {
8010  if (listEmpty(tmp4_1)) goto tmp3_end;
8011  tmpMeta[0] = MMC_CAR(tmp4_1);
8012  tmpMeta[1] = MMC_CDR(tmp4_1);
8013  _rest = tmpMeta[1];
8014  /* Pattern matching succeeded */
8015 #line 5016 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8016  tmp1 = omc_Absyn_onlyLiteralsInAnnotationMod(threadData, _rest);
8017 #line 8017 OMC_FILE
8018  goto tmp3_done;
8019  }
8020  case 4: {
8021 
8022  /* Pattern matching succeeded */
8023 #line 5021 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8024  tmp1 = 0;
8025 #line 8025 OMC_FILE
8026  goto tmp3_done;
8027  }
8028  }
8029  goto tmp3_end;
8030  tmp3_end: ;
8031  }
8032  goto goto_2;
8033  tmp3_done:
8034  (void)tmp4;
8035  MMC_RESTORE_INTERNAL(mmc_jumper);
8036  goto tmp3_done2;
8037  goto_2:;
8038  MMC_CATCH_INTERNAL(mmc_jumper);
8039  if (++tmp4 < 5) {
8040  goto tmp3_top;
8041  }
8042  MMC_THROW_INTERNAL();
8043  tmp3_done2:;
8044  }
8045  }
8046  _onlyLiterals = tmp1;
8047  _return: OMC_LABEL_UNUSED
8048  return _onlyLiterals;
8049 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
signed char modelica_boolean
float mmc_switch_type
PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_onlyLiteralsInEqMod(threadData_t *threadData, modelica_metatype _eqMod)
Definition: Absyn.c:7834
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_onlyLiteralsInAnnotationMod(threadData_t *threadData, modelica_metatype _inMod)
Definition: Absyn.c:7927
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_onlyLiteralsInEqMod()

PROTECTED_FUNCTION_STATIC modelica_boolean omc_Absyn_onlyLiteralsInEqMod ( threadData_t threadData,
modelica_metatype  _eqMod 
)

Definition at line 7834 of file Absyn.c.

7835 {
7836  modelica_boolean _onlyLiterals;
7837  modelica_boolean tmp1 = 0;
7838  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
7839  MMC_SO();
7840  _tailrecursive: OMC_LABEL_UNUSED
7841 #line 7841 OMC_FILE
7842  { /* match expression */
7843  modelica_metatype tmp4_1;
7844  tmp4_1 = _eqMod;
7845  {
7846  modelica_metatype _exp = NULL;
7847  modelica_metatype _lst = NULL;
7848  volatile mmc_switch_type tmp4;
7849  int tmp5;
7850  tmp4 = 0;
7851  for (; tmp4 < 3; tmp4++) {
7852  switch (MMC_SWITCH_CAST(tmp4)) {
7853  case 0: {
7854  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
7855  /* Pattern matching succeeded */
7856 #line 5038 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7857  tmp1 = 1;
7858 #line 7858 OMC_FILE
7859  goto tmp3_done;
7860  }
7861  case 1: {
7862  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,2) == 0) goto tmp3_end;
7863  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
7864  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],11,2) == 0) goto tmp3_end;
7865  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
7866  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto tmp3_end;
7867  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
7868  if (13 != MMC_STRLEN(tmpMeta[2]) || strcmp(MMC_STRINGDATA(_OMC_LIT15), MMC_STRINGDATA(tmpMeta[2])) != 0) goto tmp3_end;
7869 
7870  /* Pattern matching succeeded */
7871 #line 5041 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7872  tmp1 = 1;
7873 #line 7873 OMC_FILE
7874  goto tmp3_done;
7875  }
7876  case 2: {
7877  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,2) == 0) goto tmp3_end;
7878  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
7879 
7880  _exp = tmpMeta[0];
7881  /* Pattern matching succeeded */
7882 #line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7883  /* Pattern-matching tuple assignment, wild first pattern */
7884 #line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7885  omc_Absyn_traverseExpBidir(threadData, _exp, boxvar_Absyn_onlyLiteralsInExpEnter, boxvar_Absyn_onlyLiteralsInExpExit, _OMC_LIT30, &tmpMeta[0]);
7886 #line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7887  if (listEmpty(tmpMeta[0])) goto goto_2;
7888 #line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7889  tmpMeta[1] = MMC_CAR(tmpMeta[0]);
7890 #line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7891  tmpMeta[2] = MMC_CDR(tmpMeta[0]);
7892 #line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7893  if (!listEmpty(tmpMeta[2])) goto goto_2;
7894 #line 5046 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7895  _lst = tmpMeta[1];
7896 #line 7896 OMC_FILE
7897 #line 5048 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7898  tmp1 = listEmpty(_lst);
7899 #line 7899 OMC_FILE
7900  goto tmp3_done;
7901  }
7902  }
7903  goto tmp3_end;
7904  tmp3_end: ;
7905  }
7906  goto goto_2;
7907  goto_2:;
7908  MMC_THROW_INTERNAL();
7909  goto tmp3_done;
7910  tmp3_done:;
7911  }
7912  }
7913  _onlyLiterals = tmp1;
7914  _return: OMC_LABEL_UNUSED
7915  return _onlyLiterals;
7916 }
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_onlyLiteralsInExpEnter()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_onlyLiteralsInExpEnter ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_metatype  _inLst,
modelica_metatype out_outLst 
)

Definition at line 7710 of file Absyn.c.

7711 {
7712  modelica_metatype _outExp = NULL;
7713  modelica_metatype _outLst = NULL;
7714  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
7715  MMC_SO();
7716  _tailrecursive: OMC_LABEL_UNUSED
7717 #line 5065 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7718 
7719 #line 5065 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7720 
7721 #line 7721 OMC_FILE
7722  { /* match expression */
7723  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
7724  tmp4_1 = _inExp;
7725  tmp4_2 = _inLst;
7726  {
7727  modelica_boolean _b;
7728  modelica_metatype _e = NULL;
7729  modelica_metatype _lst = NULL;
7730  modelica_metatype _rest = NULL;
7731  modelica_string _name = NULL;
7732  volatile mmc_switch_type tmp4;
7733  int tmp5;
7734  tmp4 = 0;
7735  for (; tmp4 < 4; tmp4++) {
7736  switch (MMC_SWITCH_CAST(tmp4)) {
7737  case 0: {
7738  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
7739  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
7740  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],2,2) == 0) goto tmp3_end;
7741  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
7742  if (13 != MMC_STRLEN(tmpMeta[3]) || strcmp(MMC_STRINGDATA(_OMC_LIT15), MMC_STRINGDATA(tmpMeta[3])) != 0) goto tmp3_end;
7743 
7744  _rest = tmp4_2;
7745  /* Pattern matching succeeded */
7746 #line 5076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7747  tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
7748 #line 5076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7749  tmpMeta[2] = mmc_mk_cons(tmpMeta[3], _rest);
7750 #line 5076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7751  tmpMeta[0+0] = _inExp;
7752 #line 5076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7753  tmpMeta[0+1] = tmpMeta[2];
7754 #line 7754 OMC_FILE
7755  goto tmp3_done;
7756  }
7757  case 1: {
7758  if (listEmpty(tmp4_2)) goto tmp3_end;
7759  tmpMeta[2] = MMC_CAR(tmp4_2);
7760  tmpMeta[3] = MMC_CDR(tmp4_2);
7761  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
7762  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
7763  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],1,3) == 0) goto tmp3_end;
7764  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
7765 
7766  _lst = tmpMeta[2];
7767  _rest = tmpMeta[3];
7768  _e = tmp4_1;
7769  _name = tmpMeta[5];
7770  /* Pattern matching succeeded */
7771 #line 5082 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7772  _b = listMember(_name, _OMC_LIT29);
7773 #line 7773 OMC_FILE
7774 
7775 #line 5090 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7776  _lst = omc_List_consOnTrue(threadData, (!_b), _e, _lst);
7777 #line 7777 OMC_FILE
7778 #line 5091 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7779  tmpMeta[2] = mmc_mk_cons(_lst, _rest);
7780 #line 5091 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7781  tmpMeta[0+0] = _inExp;
7782 #line 5091 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7783  tmpMeta[0+1] = tmpMeta[2];
7784 #line 7784 OMC_FILE
7785  goto tmp3_done;
7786  }
7787  case 2: {
7788  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
7789  if (listEmpty(tmp4_2)) goto tmp3_end;
7790  tmpMeta[2] = MMC_CAR(tmp4_2);
7791  tmpMeta[3] = MMC_CDR(tmp4_2);
7792  _lst = tmpMeta[2];
7793  _rest = tmpMeta[3];
7794  /* Pattern matching succeeded */
7795 #line 5094 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7796  tmpMeta[3] = mmc_mk_cons(_inExp, _lst);
7797 #line 5094 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7798  tmpMeta[2] = mmc_mk_cons(tmpMeta[3], _rest);
7799 #line 5094 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7800  tmpMeta[0+0] = _inExp;
7801 #line 5094 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7802  tmpMeta[0+1] = tmpMeta[2];
7803 #line 7803 OMC_FILE
7804  goto tmp3_done;
7805  }
7806  case 3: {
7807 
7808  /* Pattern matching succeeded */
7809 #line 5096 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7810  tmpMeta[0+0] = _inExp;
7811 #line 5096 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7812  tmpMeta[0+1] = _inLst;
7813 #line 7813 OMC_FILE
7814  goto tmp3_done;
7815  }
7816  }
7817  goto tmp3_end;
7818  tmp3_end: ;
7819  }
7820  goto goto_2;
7821  goto_2:;
7822  MMC_THROW_INTERNAL();
7823  goto tmp3_done;
7824  tmp3_done:;
7825  }
7826  }
7827  _outExp = tmpMeta[0+0];
7828  _outLst = tmpMeta[0+1];
7829  _return: OMC_LABEL_UNUSED
7830  if (out_outLst) { *out_outLst = _outLst; }
7831  return _outExp;
7832 }
modelica_metatype modelica_string
signed char modelica_boolean
modelica_boolean listMember(modelica_metatype, modelica_metatype)
float mmc_switch_type
DLLExport modelica_metatype omc_List_consOnTrue(threadData_t *threadData, modelica_boolean _inCondition, modelica_metatype _inElement, modelica_metatype _inList)
Definition: List.c:18180
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_onlyLiteralsInExpExit()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_onlyLiteralsInExpExit ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_metatype  _inLst,
modelica_metatype out_outLst 
)

Definition at line 7640 of file Absyn.c.

7641 {
7642  modelica_metatype _outExp = NULL;
7643  modelica_metatype _outLst = NULL;
7644  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
7645  MMC_SO();
7646  _tailrecursive: OMC_LABEL_UNUSED
7647 #line 5110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7648 
7649 #line 5110 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7650 
7651 #line 7651 OMC_FILE
7652  { /* match expression */
7653  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
7654  tmp4_1 = _inExp;
7655  tmp4_2 = _inLst;
7656  {
7657  modelica_metatype _lst = NULL;
7658  volatile mmc_switch_type tmp4;
7659  int tmp5;
7660  tmp4 = 0;
7661  for (; tmp4 < 2; tmp4++) {
7662  switch (MMC_SWITCH_CAST(tmp4)) {
7663  case 0: {
7664  if (listEmpty(tmp4_2)) goto tmp3_end;
7665  tmpMeta[2] = MMC_CAR(tmp4_2);
7666  tmpMeta[3] = MMC_CDR(tmp4_2);
7667  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
7668  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
7669  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],2,2) == 0) goto tmp3_end;
7670  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
7671  if (13 != MMC_STRLEN(tmpMeta[5]) || strcmp(MMC_STRINGDATA(_OMC_LIT15), MMC_STRINGDATA(tmpMeta[5])) != 0) goto tmp3_end;
7672 
7673  _lst = tmpMeta[3];
7674  /* Pattern matching succeeded */
7675 #line 5116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7676  tmpMeta[0+0] = _inExp;
7677 #line 5116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7678  tmpMeta[0+1] = _lst;
7679 #line 7679 OMC_FILE
7680  goto tmp3_done;
7681  }
7682  case 1: {
7683 
7684  /* Pattern matching succeeded */
7685 #line 5119 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7686  tmpMeta[0+0] = _inExp;
7687 #line 5119 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7688  tmpMeta[0+1] = _inLst;
7689 #line 7689 OMC_FILE
7690  goto tmp3_done;
7691  }
7692  }
7693  goto tmp3_end;
7694  tmp3_end: ;
7695  }
7696  goto goto_2;
7697  goto_2:;
7698  MMC_THROW_INTERNAL();
7699  goto tmp3_done;
7700  tmp3_done:;
7701  }
7702  }
7703  _outExp = tmpMeta[0+0];
7704  _outLst = tmpMeta[0+1];
7705  _return: OMC_LABEL_UNUSED
7706  if (out_outLst) { *out_outLst = _outLst; }
7707  return _outExp;
7708 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_opEqual()

DLLExport modelica_boolean omc_Absyn_opEqual ( threadData_t threadData,
modelica_metatype  _op1,
modelica_metatype  _op2 
)

Definition at line 3441 of file Absyn.c.

3442 {
3443  modelica_boolean _isEqual;
3444  MMC_SO();
3445  _tailrecursive: OMC_LABEL_UNUSED
3446 #line 6174 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3447  _isEqual = valueEq(_op1, _op2);
3448 #line 3448 OMC_FILE
3449  _return: OMC_LABEL_UNUSED
3450  return _isEqual;
3451 }
signed char modelica_boolean
modelica_boolean valueEq(modelica_metatype lhs, modelica_metatype rhs)
Definition: meta_modelica.c:99
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_opIsElementWise()

DLLExport modelica_boolean omc_Absyn_opIsElementWise ( threadData_t threadData,
modelica_metatype  _op 
)

Definition at line 3337 of file Absyn.c.

3338 {
3339  modelica_boolean _isElementWise;
3340  modelica_boolean tmp1 = 0;
3341  MMC_SO();
3342  _tailrecursive: OMC_LABEL_UNUSED
3343 #line 3343 OMC_FILE
3344  { /* match expression */
3345  modelica_metatype tmp4_1;
3346  tmp4_1 = _op;
3347  {
3348  int tmp4;
3349  {
3350  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
3351  case 10: {
3352 
3353  /* Pattern matching succeeded */
3354 #line 6182 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3355  tmp1 = 1;
3356 #line 3356 OMC_FILE
3357  goto tmp3_done;
3358  }
3359  case 11: {
3360 
3361  /* Pattern matching succeeded */
3362 #line 6183 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3363  tmp1 = 1;
3364 #line 3364 OMC_FILE
3365  goto tmp3_done;
3366  }
3367  case 12: {
3368 
3369  /* Pattern matching succeeded */
3370 #line 6184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3371  tmp1 = 1;
3372 #line 3372 OMC_FILE
3373  goto tmp3_done;
3374  }
3375  case 13: {
3376 
3377  /* Pattern matching succeeded */
3378 #line 6185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3379  tmp1 = 1;
3380 #line 3380 OMC_FILE
3381  goto tmp3_done;
3382  }
3383  case 14: {
3384 
3385  /* Pattern matching succeeded */
3386 #line 6186 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3387  tmp1 = 1;
3388 #line 3388 OMC_FILE
3389  goto tmp3_done;
3390  }
3391  case 15: {
3392 
3393  /* Pattern matching succeeded */
3394 #line 6187 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3395  tmp1 = 1;
3396 #line 3396 OMC_FILE
3397  goto tmp3_done;
3398  }
3399  case 16: {
3400 
3401  /* Pattern matching succeeded */
3402 #line 6188 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3403  tmp1 = 1;
3404 #line 3404 OMC_FILE
3405  goto tmp3_done;
3406  }
3407  default:
3408  tmp3_default: OMC_LABEL_UNUSED; {
3409 
3410  /* Pattern matching succeeded */
3411 #line 6189 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3412  tmp1 = 0;
3413 #line 3413 OMC_FILE
3414  goto tmp3_done;
3415  }
3416  }
3417  goto tmp3_end;
3418  tmp3_end: ;
3419  }
3420  goto goto_2;
3421  goto_2:;
3422  MMC_THROW_INTERNAL();
3423  goto tmp3_done;
3424  tmp3_done:;
3425  }
3426  }
3427  _isElementWise = tmp1;
3428  _return: OMC_LABEL_UNUSED
3429  return _isElementWise;
3430 }
signed char modelica_boolean
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_optArrayDimEqual()

DLLExport modelica_boolean omc_Absyn_optArrayDimEqual ( threadData_t threadData,
modelica_metatype  _oad1,
modelica_metatype  _oad2 
)

Definition at line 17375 of file Absyn.c.

17376 {
17377  modelica_boolean _b;
17378  modelica_boolean tmp1 = 0;
17379  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
17380  MMC_SO();
17381  _tailrecursive: OMC_LABEL_UNUSED
17382 #line 17382 OMC_FILE
17383  { /* matchcontinue expression */
17384  volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
17385  tmp4_1 = _oad1;
17386  tmp4_2 = _oad2;
17387  {
17388  modelica_metatype _ad1 = NULL;
17389  modelica_metatype _ad2 = NULL;
17390  volatile mmc_switch_type tmp4;
17391  int tmp5;
17392  tmp4 = 0;
17393  MMC_TRY_INTERNAL(mmc_jumper)
17394  tmp3_top:
17395  threadData->mmc_jumper = &new_mmc_jumper;
17396  for (; tmp4 < 3; tmp4++) {
17397  switch (MMC_SWITCH_CAST(tmp4)) {
17398  case 0: {
17399  modelica_boolean tmp6;
17400  if (optionNone(tmp4_1)) goto tmp3_end;
17401  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
17402  if (optionNone(tmp4_2)) goto tmp3_end;
17403  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 1));
17404  _ad1 = tmpMeta[0];
17405  _ad2 = tmpMeta[1];
17406  tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
17407 #line 2615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17408  /* Pattern-matching assignment */
17409 #line 2615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17410  tmp6 = omc_List_isEqualOnTrue(threadData, _ad1, _ad2, boxvar_Absyn_subscriptEqual);
17411 #line 2615 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17412  if (1 != tmp6) goto goto_2;
17413 #line 17413 OMC_FILE
17414 #line 2616 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17415  tmp1 = 1;
17416 #line 17416 OMC_FILE
17417  goto tmp3_done;
17418  }
17419  case 1: {
17420  if (!optionNone(tmp4_1)) goto tmp3_end;
17421  if (!optionNone(tmp4_2)) goto tmp3_end;
17422  /* Pattern matching succeeded */
17423 #line 2617 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17424  tmp1 = 1;
17425 #line 17425 OMC_FILE
17426  goto tmp3_done;
17427  }
17428  case 2: {
17429 
17430  /* Pattern matching succeeded */
17431 #line 2618 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17432  tmp1 = 0;
17433 #line 17433 OMC_FILE
17434  goto tmp3_done;
17435  }
17436  }
17437  goto tmp3_end;
17438  tmp3_end: ;
17439  }
17440  goto goto_2;
17441  tmp3_done:
17442  (void)tmp4;
17443  MMC_RESTORE_INTERNAL(mmc_jumper);
17444  goto tmp3_done2;
17445  goto_2:;
17446  MMC_CATCH_INTERNAL(mmc_jumper);
17447  if (++tmp4 < 3) {
17448  goto tmp3_top;
17449  }
17450  MMC_THROW_INTERNAL();
17451  tmp3_done2:;
17452  }
17453  }
17454  _b = tmp1;
17455  _return: OMC_LABEL_UNUSED
17456  return _b;
17457 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_List_isEqualOnTrue(threadData_t *threadData, modelica_metatype _inList1, modelica_metatype _inList2, modelica_fnptr _inCompFunc)
Definition: List.c:18331
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_optMsg()

DLLExport modelica_metatype omc_Absyn_optMsg ( threadData_t threadData,
modelica_boolean  _inShowMessage,
modelica_metatype  _inInfo 
)

Definition at line 2091 of file Absyn.c.

2092 {
2093  modelica_metatype _outMsg = NULL;
2094  modelica_boolean tmp1;
2095  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
2096  MMC_SO();
2097  _tailrecursive: OMC_LABEL_UNUSED
2098 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2099  tmp1 = (modelica_boolean)_inShowMessage;
2100 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2101  if(tmp1)
2102 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2103  {
2104 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2105  tmpMeta[0] = mmc_mk_box2(3, &Absyn_Msg_MSG__desc, _inInfo);
2106 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2107  tmpMeta[1] = tmpMeta[0];
2108 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2109  }
2110 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2111  else
2112 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2113  {
2114 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2115  tmpMeta[1] = _OMC_LIT0;
2116 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2117  }
2118 #line 6563 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2119  _outMsg = tmpMeta[1];
2120 #line 2120 OMC_FILE
2121  _return: OMC_LABEL_UNUSED
2122  return _outMsg;
2123 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Msg_MSG__desc
signed char modelica_boolean
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_optPathString()

DLLExport modelica_string omc_Absyn_optPathString ( threadData_t threadData,
modelica_metatype  _inPathOption 
)

Definition at line 16185 of file Absyn.c.

16186 {
16187  modelica_string _outString = NULL;
16188  modelica_string tmp1 = 0;
16189  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
16190  MMC_SO();
16191  _tailrecursive: OMC_LABEL_UNUSED
16192 #line 16192 OMC_FILE
16193  { /* match expression */
16194  modelica_metatype tmp4_1;
16195  tmp4_1 = _inPathOption;
16196  {
16197  modelica_metatype _p = NULL;
16198  volatile mmc_switch_type tmp4;
16199  int tmp5;
16200  tmp4 = 0;
16201  for (; tmp4 < 2; tmp4++) {
16202  switch (MMC_SWITCH_CAST(tmp4)) {
16203  case 0: {
16204  if (!optionNone(tmp4_1)) goto tmp3_end;
16205  /* Pattern matching succeeded */
16206 #line 2838 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16207  tmp1 = _OMC_LIT2;
16208 #line 16208 OMC_FILE
16209  goto tmp3_done;
16210  }
16211  case 1: {
16212  if (optionNone(tmp4_1)) goto tmp3_end;
16213  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
16214  _p = tmpMeta[0];
16215  /* Pattern matching succeeded */
16216 #line 2841 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16217  tmp1 = omc_Absyn_pathString(threadData, _p, _OMC_LIT1, 1, 0);
16218 #line 16218 OMC_FILE
16219  goto tmp3_done;
16220  }
16221  }
16222  goto tmp3_end;
16223  tmp3_end: ;
16224  }
16225  goto goto_2;
16226  goto_2:;
16227  MMC_THROW_INTERNAL();
16228  goto tmp3_done;
16229  tmp3_done:;
16230  }
16231  }
16232  _outString = tmp1;
16233  _return: OMC_LABEL_UNUSED
16234  return _outString;
16235 }
modelica_metatype modelica_string
float mmc_switch_type
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_pathAppendList()

DLLExport modelica_metatype omc_Absyn_pathAppendList ( threadData_t threadData,
modelica_metatype  _inPathLst 
)

Definition at line 12550 of file Absyn.c.

12551 {
12552  modelica_metatype _outPath = NULL;
12553  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
12554  MMC_SO();
12555  _tailrecursive: OMC_LABEL_UNUSED
12556 #line 12556 OMC_FILE
12557  { /* match expression */
12558  modelica_metatype tmp3_1;
12559  tmp3_1 = _inPathLst;
12560  {
12561  modelica_metatype _path = NULL;
12562  modelica_metatype _first = NULL;
12563  modelica_metatype _rest = NULL;
12564  volatile mmc_switch_type tmp3;
12565  int tmp4;
12566  tmp3 = 0;
12567  for (; tmp3 < 3; tmp3++) {
12568  switch (MMC_SWITCH_CAST(tmp3)) {
12569  case 0: {
12570  if (!listEmpty(tmp3_1)) goto tmp2_end;
12571  /* Pattern matching succeeded */
12572 #line 3865 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12573  tmpMeta[0] = _OMC_LIT52;
12574 #line 12574 OMC_FILE
12575  goto tmp2_done;
12576  }
12577  case 1: {
12578  if (listEmpty(tmp3_1)) goto tmp2_end;
12579  tmpMeta[1] = MMC_CAR(tmp3_1);
12580  tmpMeta[2] = MMC_CDR(tmp3_1);
12581  if (!listEmpty(tmpMeta[2])) goto tmp2_end;
12582  _path = tmpMeta[1];
12583  /* Pattern matching succeeded */
12584 #line 3866 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12585  tmpMeta[0] = _path;
12586 #line 12586 OMC_FILE
12587  goto tmp2_done;
12588  }
12589  case 2: {
12590  if (listEmpty(tmp3_1)) goto tmp2_end;
12591  tmpMeta[1] = MMC_CAR(tmp3_1);
12592  tmpMeta[2] = MMC_CDR(tmp3_1);
12593  _first = tmpMeta[1];
12594  _rest = tmpMeta[2];
12595  /* Pattern matching succeeded */
12596 #line 3869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12597  _path = omc_Absyn_pathAppendList(threadData, _rest);
12598 #line 12598 OMC_FILE
12599 #line 3870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12600  tmpMeta[0] = omc_Absyn_joinPaths(threadData, _first, _path);
12601 #line 12601 OMC_FILE
12602  goto tmp2_done;
12603  }
12604  }
12605  goto tmp2_end;
12606  tmp2_end: ;
12607  }
12608  goto goto_1;
12609  goto_1:;
12610  MMC_THROW_INTERNAL();
12611  goto tmp2_done;
12612  tmp2_done:;
12613  }
12614  }
12615  _outPath = tmpMeta[0];
12616  _return: OMC_LABEL_UNUSED
12617  return _outPath;
12618 }
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_joinPaths(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:12781
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_pathAppendList(threadData_t *threadData, modelica_metatype _inPathLst)
Definition: Absyn.c:12550
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathCompare()

DLLExport modelica_integer omc_Absyn_pathCompare ( threadData_t threadData,
modelica_metatype  _ip1,
modelica_metatype  _ip2 
)

Definition at line 16507 of file Absyn.c.

16508 {
16509  modelica_integer _o;
16510  modelica_integer tmp1 = 0;
16511  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
16512  MMC_SO();
16513  _tailrecursive: OMC_LABEL_UNUSED
16514 #line 16514 OMC_FILE
16515  { /* match expression */
16516  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
16517  tmp4_1 = _ip1;
16518  tmp4_2 = _ip2;
16519  {
16520  modelica_metatype _p1 = NULL;
16521  modelica_metatype _p2 = NULL;
16522  modelica_string _i1 = NULL;
16523  modelica_string _i2 = NULL;
16524  volatile mmc_switch_type tmp4;
16525  int tmp5;
16526  tmp4 = 0;
16527  for (; tmp4 < 7; tmp4++) {
16528  switch (MMC_SWITCH_CAST(tmp4)) {
16529  case 0: {
16530  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
16531  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16532  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
16533  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
16534  _p1 = tmpMeta[0];
16535  _p2 = tmpMeta[1];
16536  /* Pattern matching succeeded */
16537 #line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16538  /* Tail recursive call */
16539 #line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16540  _ip1 = _p1;
16541 #line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16542  _ip2 = _p2;
16543 #line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16544  goto _tailrecursive;
16545 #line 2764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16546  /* TODO: Make sure any eventual dead code below is never generated */
16547 #line 16547 OMC_FILE
16548  goto tmp3_done;
16549  }
16550  case 1: {
16551  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
16552 
16553  /* Pattern matching succeeded */
16554 #line 2765 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16555  tmp1 = ((modelica_integer) 1);
16556 #line 16556 OMC_FILE
16557  goto tmp3_done;
16558  }
16559  case 2: {
16560  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
16561 
16562  /* Pattern matching succeeded */
16563 #line 2766 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16564  tmp1 = ((modelica_integer) -1);
16565 #line 16565 OMC_FILE
16566  goto tmp3_done;
16567  }
16568  case 3: {
16569  modelica_boolean tmp6;
16570  modelica_integer tmp7;
16571  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
16572  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16573  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
16574  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
16575  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
16576  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
16577  _i1 = tmpMeta[0];
16578  _p1 = tmpMeta[1];
16579  _i2 = tmpMeta[2];
16580  _p2 = tmpMeta[3];
16581  /* Pattern matching succeeded */
16582 #line 2769 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16583  _o = stringCompare(_i1, _i2);
16584 #line 16584 OMC_FILE
16585 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16586  tmp6 = (modelica_boolean)((modelica_integer)_o == ((modelica_integer) 0));
16587 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16588  if(tmp6)
16589 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16590  {
16591 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16592  /* Tail recursive call */
16593 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16594  _ip1 = _p1;
16595 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16596  _ip2 = _p2;
16597 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16598  goto _tailrecursive;
16599 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16600  /* TODO: Make sure any eventual dead code below is never generated */
16601 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16602  }
16603 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16604  else
16605 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16606  {
16607 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16608  tmp7 = (modelica_integer)_o;
16609 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16610  }
16611 #line 2770 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16612  tmp1 = tmp7;
16613 #line 16613 OMC_FILE
16614  goto tmp3_done;
16615  }
16616  case 4: {
16617  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
16618 
16619  /* Pattern matching succeeded */
16620 #line 2772 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16621  tmp1 = ((modelica_integer) 1);
16622 #line 16622 OMC_FILE
16623  goto tmp3_done;
16624  }
16625  case 5: {
16626  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
16627 
16628  /* Pattern matching succeeded */
16629 #line 2773 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16630  tmp1 = ((modelica_integer) -1);
16631 #line 16631 OMC_FILE
16632  goto tmp3_done;
16633  }
16634  case 6: {
16635  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
16636  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16637  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
16638  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
16639  _i1 = tmpMeta[0];
16640  _i2 = tmpMeta[1];
16641  /* Pattern matching succeeded */
16642 #line 2775 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16643  tmp1 = stringCompare(_i1, _i2);
16644 #line 16644 OMC_FILE
16645  goto tmp3_done;
16646  }
16647  }
16648  goto tmp3_end;
16649  tmp3_end: ;
16650  }
16651  goto goto_2;
16652  goto_2:;
16653  MMC_THROW_INTERNAL();
16654  goto tmp3_done;
16655  tmp3_done:;
16656  }
16657  }
16658  _o = tmp1;
16659  _return: OMC_LABEL_UNUSED
16660  return _o;
16661 }
modelica_metatype modelica_string
m_integer modelica_integer
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathCompareNoQual()

DLLExport modelica_integer omc_Absyn_pathCompareNoQual ( threadData_t threadData,
modelica_metatype  _ip1,
modelica_metatype  _ip2 
)

Definition at line 16369 of file Absyn.c.

16370 {
16371  modelica_integer _o;
16372  modelica_integer tmp1 = 0;
16373  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
16374  MMC_SO();
16375  _tailrecursive: OMC_LABEL_UNUSED
16376 #line 16376 OMC_FILE
16377  { /* match expression */
16378  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
16379  tmp4_1 = _ip1;
16380  tmp4_2 = _ip2;
16381  {
16382  modelica_metatype _p1 = NULL;
16383  modelica_metatype _p2 = NULL;
16384  modelica_string _i1 = NULL;
16385  modelica_string _i2 = NULL;
16386  volatile mmc_switch_type tmp4;
16387  int tmp5;
16388  tmp4 = 0;
16389  for (; tmp4 < 6; tmp4++) {
16390  switch (MMC_SWITCH_CAST(tmp4)) {
16391  case 0: {
16392  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
16393  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16394 
16395  _p1 = tmpMeta[0];
16396  _p2 = tmp4_2;
16397  /* Pattern matching succeeded */
16398 #line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16399  /* Tail recursive call */
16400 #line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16401  _ip1 = _p1;
16402 #line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16403  _ip2 = _p2;
16404 #line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16405  goto _tailrecursive;
16406 #line 2788 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16407  /* TODO: Make sure any eventual dead code below is never generated */
16408 #line 16408 OMC_FILE
16409  goto tmp3_done;
16410  }
16411  case 1: {
16412  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
16413  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
16414 
16415  _p2 = tmpMeta[0];
16416  _p1 = tmp4_1;
16417  /* Pattern matching succeeded */
16418 #line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16419  /* Tail recursive call */
16420 #line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16421  _ip1 = _p1;
16422 #line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16423  _ip2 = _p2;
16424 #line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16425  goto _tailrecursive;
16426 #line 2789 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16427  /* TODO: Make sure any eventual dead code below is never generated */
16428 #line 16428 OMC_FILE
16429  goto tmp3_done;
16430  }
16431  case 2: {
16432  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
16433  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16434  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
16435  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
16436  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
16437  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
16438  _i1 = tmpMeta[0];
16439  _p1 = tmpMeta[1];
16440  _i2 = tmpMeta[2];
16441  _p2 = tmpMeta[3];
16442  /* Pattern matching succeeded */
16443 #line 2792 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16444  _o = stringCompare(_i1, _i2);
16445 #line 16445 OMC_FILE
16446 #line 2793 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16447  tmp1 = (((modelica_integer)_o == ((modelica_integer) 0))?omc_Absyn_pathCompare(threadData, _p1, _p2):(modelica_integer)_o);
16448 #line 16448 OMC_FILE
16449  goto tmp3_done;
16450  }
16451  case 3: {
16452  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
16453 
16454  /* Pattern matching succeeded */
16455 #line 2795 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16456  tmp1 = ((modelica_integer) 1);
16457 #line 16457 OMC_FILE
16458  goto tmp3_done;
16459  }
16460  case 4: {
16461  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
16462 
16463  /* Pattern matching succeeded */
16464 #line 2796 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16465  tmp1 = ((modelica_integer) -1);
16466 #line 16466 OMC_FILE
16467  goto tmp3_done;
16468  }
16469  case 5: {
16470  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
16471  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16472  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
16473  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
16474  _i1 = tmpMeta[0];
16475  _i2 = tmpMeta[1];
16476  /* Pattern matching succeeded */
16477 #line 2798 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16478  tmp1 = stringCompare(_i1, _i2);
16479 #line 16479 OMC_FILE
16480  goto tmp3_done;
16481  }
16482  }
16483  goto tmp3_end;
16484  tmp3_end: ;
16485  }
16486  goto goto_2;
16487  goto_2:;
16488  MMC_THROW_INTERNAL();
16489  goto tmp3_done;
16490  tmp3_done:;
16491  }
16492  }
16493  _o = tmp1;
16494  _return: OMC_LABEL_UNUSED
16495  return _o;
16496 }
modelica_metatype modelica_string
m_integer modelica_integer
float mmc_switch_type
DLLExport modelica_integer omc_Absyn_pathCompare(threadData_t *threadData, modelica_metatype _ip1, modelica_metatype _ip2)
Definition: Absyn.c:16507
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathContainedIn()

DLLExport modelica_metatype omc_Absyn_pathContainedIn ( threadData_t threadData,
modelica_metatype  _subPath,
modelica_metatype  _path 
)

Definition at line 13843 of file Absyn.c.

13844 {
13845  modelica_metatype _completePath = NULL;
13846  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
13847  MMC_SO();
13848  _tailrecursive: OMC_LABEL_UNUSED
13849 #line 13849 OMC_FILE
13850  { /* matchcontinue expression */
13851  {
13852  modelica_string _ident = NULL;
13853  modelica_metatype _newPath = NULL;
13854  modelica_metatype _newSubPath = NULL;
13855  volatile mmc_switch_type tmp3;
13856  int tmp4;
13857  tmp3 = 0;
13858  MMC_TRY_INTERNAL(mmc_jumper)
13859  tmp2_top:
13860  threadData->mmc_jumper = &new_mmc_jumper;
13861  for (; tmp3 < 3; tmp3++) {
13862  switch (MMC_SWITCH_CAST(tmp3)) {
13863  case 0: {
13864  modelica_boolean tmp5;
13865  /* Pattern matching succeeded */
13866 #line 3482 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13867  /* Pattern-matching assignment */
13868 #line 3482 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13869  tmp5 = omc_Absyn_pathSuffixOf(threadData, _subPath, _path);
13870 #line 3482 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13871  if (1 != tmp5) goto goto_1;
13872 #line 13872 OMC_FILE
13873 #line 3483 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13874  tmpMeta[0] = _path;
13875 #line 13875 OMC_FILE
13876  goto tmp2_done;
13877  }
13878  case 1: {
13879  /* Pattern matching succeeded */
13880 #line 3488 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13881  _ident = omc_Absyn_pathLastIdent(threadData, _path);
13882 #line 13882 OMC_FILE
13883 
13884 #line 3489 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13885  _newPath = omc_Absyn_stripLast(threadData, _path);
13886 #line 13886 OMC_FILE
13887 
13888 #line 3490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13889  _newPath = omc_Absyn_pathContainedIn(threadData, _subPath, _newPath);
13890 #line 13890 OMC_FILE
13891 #line 3491 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13892  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _ident);
13893 #line 3491 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13894  tmpMeta[0] = omc_Absyn_joinPaths(threadData, _newPath, tmpMeta[1]);
13895 #line 13895 OMC_FILE
13896  goto tmp2_done;
13897  }
13898  case 2: {
13899  /* Pattern matching succeeded */
13900 #line 3496 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13901  _ident = omc_Absyn_pathLastIdent(threadData, _subPath);
13902 #line 13902 OMC_FILE
13903 
13904 #line 3497 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13905  _newSubPath = omc_Absyn_stripLast(threadData, _subPath);
13906 #line 13906 OMC_FILE
13907 
13908 #line 3498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13909  _newSubPath = omc_Absyn_pathContainedIn(threadData, _newSubPath, _path);
13910 #line 13910 OMC_FILE
13911 #line 3499 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13912  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _ident);
13913 #line 3499 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13914  tmpMeta[0] = omc_Absyn_joinPaths(threadData, _newSubPath, tmpMeta[1]);
13915 #line 13915 OMC_FILE
13916  goto tmp2_done;
13917  }
13918  }
13919  goto tmp2_end;
13920  tmp2_end: ;
13921  }
13922  goto goto_1;
13923  tmp2_done:
13924  (void)tmp3;
13925  MMC_RESTORE_INTERNAL(mmc_jumper);
13926  goto tmp2_done2;
13927  goto_1:;
13928  MMC_CATCH_INTERNAL(mmc_jumper);
13929  if (++tmp3 < 3) {
13930  goto tmp2_top;
13931  }
13932  MMC_THROW_INTERNAL();
13933  tmp2_done2:;
13934  }
13935  }
13936  _completePath = tmpMeta[0];
13937  _return: OMC_LABEL_UNUSED
13938  return _completePath;
13939 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
DLLExport modelica_metatype omc_Absyn_joinPaths(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:12781
DLLExport modelica_metatype omc_Absyn_pathContainedIn(threadData_t *threadData, modelica_metatype _subPath, modelica_metatype _path)
Definition: Absyn.c:13843
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_pathSuffixOf(threadData_t *threadData, modelica_metatype _suffix_path, modelica_metatype _path)
Definition: Absyn.c:15029
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
DLLExport modelica_metatype omc_Absyn_stripLast(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:12468
DLLExport modelica_string omc_Absyn_pathLastIdent(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:15796
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathContains()

DLLExport modelica_boolean omc_Absyn_pathContains ( threadData_t threadData,
modelica_metatype  _fullPath,
modelica_metatype  _pathId 
)

Definition at line 14041 of file Absyn.c.

14042 {
14043  modelica_boolean _b;
14044  modelica_boolean tmp1 = 0;
14045  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
14046  MMC_SO();
14047  _tailrecursive: OMC_LABEL_UNUSED
14048 #line 14048 OMC_FILE
14049  { /* match expression */
14050  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
14051  tmp4_1 = _fullPath;
14052  tmp4_2 = _pathId;
14053  {
14054  modelica_string _str1 = NULL;
14055  modelica_string _str2 = NULL;
14056  modelica_metatype _qp = NULL;
14057  modelica_boolean _b1;
14058  modelica_boolean _b2;
14059  int tmp4;
14060  {
14061  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
14062  case 4: {
14063  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
14064  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
14065  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
14066  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
14067  _str1 = tmpMeta[0];
14068  _str2 = tmpMeta[1];
14069  /* Pattern matching succeeded */
14070 #line 3418 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14071  tmp1 = (stringEqual(_str1, _str2));
14072 #line 14072 OMC_FILE
14073  goto tmp3_done;
14074  }
14075  case 3: {
14076  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
14077  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
14078  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
14079  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
14080  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
14081  _str1 = tmpMeta[0];
14082  _qp = tmpMeta[1];
14083  _str2 = tmpMeta[2];
14084  /* Pattern matching succeeded */
14085 #line 3422 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14086  _b1 = (stringEqual(_str1, _str2));
14087 #line 14087 OMC_FILE
14088 
14089 #line 3423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14090  _b2 = omc_Absyn_pathContains(threadData, _qp, _pathId);
14091 #line 14091 OMC_FILE
14092 #line 3424 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14093  tmp1 = (_b1 || _b2);
14094 #line 14094 OMC_FILE
14095  goto tmp3_done;
14096  }
14097  case 5: {
14098  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
14099  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
14100 
14101  _qp = tmpMeta[0];
14102  /* Pattern matching succeeded */
14103 #line 3428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14104  /* Tail recursive call */
14105 #line 3428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14106  _fullPath = _qp;
14107 #line 3428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14108  goto _tailrecursive;
14109 #line 3428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14110  /* TODO: Make sure any eventual dead code below is never generated */
14111 #line 14111 OMC_FILE
14112  goto tmp3_done;
14113  }
14114  }
14115  goto tmp3_end;
14116  tmp3_end: ;
14117  }
14118  goto goto_2;
14119  goto_2:;
14120  MMC_THROW_INTERNAL();
14121  goto tmp3_done;
14122  tmp3_done:;
14123  }
14124  }
14125  _b = tmp1;
14126  _return: OMC_LABEL_UNUSED
14127  return _b;
14128 }
modelica_metatype modelica_string
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathContains(threadData_t *threadData, modelica_metatype _fullPath, modelica_metatype _pathId)
Definition: Absyn.c:14041
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathContainsString()

DLLExport modelica_boolean omc_Absyn_pathContainsString ( threadData_t threadData,
modelica_metatype  _p1,
modelica_string  _str 
)

Definition at line 13942 of file Absyn.c.

13943 {
13944  modelica_boolean _b;
13945  modelica_boolean tmp1 = 0;
13946  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
13947  MMC_SO();
13948  _tailrecursive: OMC_LABEL_UNUSED
13949 #line 13949 OMC_FILE
13950  { /* match expression */
13951  modelica_metatype tmp4_1;modelica_string tmp4_2;
13952  tmp4_1 = _p1;
13953  tmp4_2 = _str;
13954  {
13955  modelica_string _str1 = NULL;
13956  modelica_string _searchStr = NULL;
13957  modelica_metatype _qp = NULL;
13958  modelica_boolean _b1;
13959  modelica_boolean _b2;
13960  int tmp4;
13961  {
13962  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
13963  case 4: {
13964  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
13965  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
13966 
13967  _str1 = tmpMeta[0];
13968  _searchStr = tmp4_2;
13969  /* Pattern matching succeeded */
13970 #line 3447 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13971  tmp1 = (omc_System_stringFind(threadData, _str1, _searchStr) != ((modelica_integer) -1));
13972 #line 13972 OMC_FILE
13973  goto tmp3_done;
13974  }
13975  case 3: {
13976  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
13977  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
13978  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
13979 
13980  _str1 = tmpMeta[0];
13981  _qp = tmpMeta[1];
13982  _searchStr = tmp4_2;
13983  /* Pattern matching succeeded */
13984 #line 3452 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13985  _b1 = (omc_System_stringFind(threadData, _str1, _searchStr) != ((modelica_integer) -1));
13986 #line 13986 OMC_FILE
13987 
13988 #line 3453 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13989  _b2 = omc_Absyn_pathContainsString(threadData, _qp, _searchStr);
13990 #line 13990 OMC_FILE
13991 #line 3454 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
13992  tmp1 = (_b1 || _b2);
13993 #line 13993 OMC_FILE
13994  goto tmp3_done;
13995  }
13996  case 5: {
13997  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
13998  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
13999 
14000  _qp = tmpMeta[0];
14001  _searchStr = tmp4_2;
14002  /* Pattern matching succeeded */
14003 #line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14004  /* Tail recursive call */
14005 #line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14006  _p1 = _qp;
14007 #line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14008  _str = _searchStr;
14009 #line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14010  goto _tailrecursive;
14011 #line 3458 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14012  /* TODO: Make sure any eventual dead code below is never generated */
14013 #line 14013 OMC_FILE
14014  goto tmp3_done;
14015  }
14016  }
14017  goto tmp3_end;
14018  tmp3_end: ;
14019  }
14020  goto goto_2;
14021  goto_2:;
14022  MMC_THROW_INTERNAL();
14023  goto tmp3_done;
14024  tmp3_done:;
14025  }
14026  }
14027  _b = tmp1;
14028  _return: OMC_LABEL_UNUSED
14029  return _b;
14030 }
modelica_metatype modelica_string
DLLExport modelica_boolean omc_Absyn_pathContainsString(threadData_t *threadData, modelica_metatype _p1, modelica_string _str)
Definition: Absyn.c:13942
m_integer modelica_integer
signed char modelica_boolean
void * modelica_metatype
modelica_integer omc_System_stringFind(threadData_t *threadData, modelica_string _str, modelica_string _searchStr)
Definition: System.c:4617
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathEqual()

DLLExport modelica_boolean omc_Absyn_pathEqual ( threadData_t threadData,
modelica_metatype  _inPath1,
modelica_metatype  _inPath2 
)

Definition at line 17616 of file Absyn.c.

17617 {
17618  modelica_boolean _outBoolean;
17619  modelica_boolean tmp1 = 0;
17620  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
17621  MMC_SO();
17622  _tailrecursive: OMC_LABEL_UNUSED
17623 #line 17623 OMC_FILE
17624  { /* match expression */
17625  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
17626  tmp4_1 = _inPath1;
17627  tmp4_2 = _inPath2;
17628  {
17629  modelica_string _id1 = NULL;
17630  modelica_string _id2 = NULL;
17631  modelica_metatype _path1 = NULL;
17632  modelica_metatype _path2 = NULL;
17633  volatile mmc_switch_type tmp4;
17634  int tmp5;
17635  tmp4 = 0;
17636  for (; tmp4 < 5; tmp4++) {
17637  switch (MMC_SWITCH_CAST(tmp4)) {
17638  case 0: {
17639  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
17640  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17641 
17642  _path1 = tmpMeta[0];
17643  _path2 = tmp4_2;
17644  /* Pattern matching succeeded */
17645 #line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17646  /* Tail recursive call */
17647 #line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17648  _inPath1 = _path1;
17649 #line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17650  _inPath2 = _path2;
17651 #line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17652  goto _tailrecursive;
17653 #line 2557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17654  /* TODO: Make sure any eventual dead code below is never generated */
17655 #line 17655 OMC_FILE
17656  goto tmp3_done;
17657  }
17658  case 1: {
17659  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
17660  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
17661 
17662  _path2 = tmpMeta[0];
17663  _path1 = tmp4_1;
17664  /* Pattern matching succeeded */
17665 #line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17666  /* Tail recursive call */
17667 #line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17668  _inPath1 = _path1;
17669 #line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17670  _inPath2 = _path2;
17671 #line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17672  goto _tailrecursive;
17673 #line 2559 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17674  /* TODO: Make sure any eventual dead code below is never generated */
17675 #line 17675 OMC_FILE
17676  goto tmp3_done;
17677  }
17678  case 2: {
17679  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
17680  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17681  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
17682  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
17683  _id1 = tmpMeta[0];
17684  _id2 = tmpMeta[1];
17685  /* Pattern matching succeeded */
17686 #line 2562 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17687  tmp1 = (stringEqual(_id1, _id2));
17688 #line 17688 OMC_FILE
17689  goto tmp3_done;
17690  }
17691  case 3: {
17692  modelica_boolean tmp6;
17693  modelica_boolean tmp7;
17694  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
17695  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17696  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
17697  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
17698  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
17699  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
17700  _id1 = tmpMeta[0];
17701  _path1 = tmpMeta[1];
17702  _id2 = tmpMeta[2];
17703  _path2 = tmpMeta[3];
17704  /* Pattern matching succeeded */
17705 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17706  tmp6 = (modelica_boolean)(stringEqual(_id1, _id2));
17707 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17708  if(tmp6)
17709 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17710  {
17711 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17712  /* Tail recursive call */
17713 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17714  _inPath1 = _path1;
17715 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17716  _inPath2 = _path2;
17717 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17718  goto _tailrecursive;
17719 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17720  /* TODO: Make sure any eventual dead code below is never generated */
17721 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17722  }
17723 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17724  else
17725 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17726  {
17727 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17728  tmp7 = 0;
17729 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17730  }
17731 #line 2566 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17732  tmp1 = tmp7;
17733 #line 17733 OMC_FILE
17734  goto tmp3_done;
17735  }
17736  case 4: {
17737 
17738  /* Pattern matching succeeded */
17739 #line 2569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17740  tmp1 = 0;
17741 #line 17741 OMC_FILE
17742  goto tmp3_done;
17743  }
17744  }
17745  goto tmp3_end;
17746  tmp3_end: ;
17747  }
17748  goto goto_2;
17749  goto_2:;
17750  MMC_THROW_INTERNAL();
17751  goto tmp3_done;
17752  tmp3_done:;
17753  }
17754  }
17755  _outBoolean = tmp1;
17756  _return: OMC_LABEL_UNUSED
17757  return _outBoolean;
17758 }
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathFirstIdent()

DLLExport modelica_string omc_Absyn_pathFirstIdent ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 15652 of file Absyn.c.

15653 {
15654  modelica_string _outIdent = NULL;
15655  modelica_string tmp1 = 0;
15656  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
15657  MMC_SO();
15658  _tailrecursive: OMC_LABEL_UNUSED
15659 #line 15659 OMC_FILE
15660  { /* match expression */
15661  modelica_metatype tmp4_1;
15662  tmp4_1 = _inPath;
15663  {
15664  modelica_string _n = NULL;
15665  modelica_metatype _p = NULL;
15666  int tmp4;
15667  {
15668  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
15669  case 5: {
15670  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
15671  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
15672  _p = tmpMeta[0];
15673  /* Pattern matching succeeded */
15674 #line 2988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15675  /* Tail recursive call */
15676 #line 2988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15677  _inPath = _p;
15678 #line 2988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15679  goto _tailrecursive;
15680 #line 2988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15681  /* TODO: Make sure any eventual dead code below is never generated */
15682 #line 15682 OMC_FILE
15683  goto tmp3_done;
15684  }
15685  case 3: {
15686  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
15687  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
15688 
15689  _n = tmpMeta[0];
15690  /* Pattern matching succeeded */
15691 #line 2989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15692  tmp1 = _n;
15693 #line 15693 OMC_FILE
15694  goto tmp3_done;
15695  }
15696  case 4: {
15697  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
15698  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
15699  _n = tmpMeta[0];
15700  /* Pattern matching succeeded */
15701 #line 2990 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15702  tmp1 = _n;
15703 #line 15703 OMC_FILE
15704  goto tmp3_done;
15705  }
15706  }
15707  goto tmp3_end;
15708  tmp3_end: ;
15709  }
15710  goto goto_2;
15711  goto_2:;
15712  MMC_THROW_INTERNAL();
15713  goto tmp3_done;
15714  tmp3_done:;
15715  }
15716  }
15717  _outIdent = tmp1;
15718  _return: OMC_LABEL_UNUSED
15719  return _outIdent;
15720 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathFirstPath()

DLLExport modelica_metatype omc_Absyn_pathFirstPath ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 15583 of file Absyn.c.

15584 {
15585  modelica_metatype _outPath = NULL;
15586  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
15587  MMC_SO();
15588  _tailrecursive: OMC_LABEL_UNUSED
15589 #line 15589 OMC_FILE
15590  { /* match expression */
15591  modelica_metatype tmp3_1;
15592  tmp3_1 = _inPath;
15593  {
15594  modelica_string _n = NULL;
15595  int tmp3;
15596  {
15597  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
15598  case 4: {
15599 
15600  /* Pattern matching succeeded */
15601 #line 3002 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15602  tmpMeta[0] = _inPath;
15603 #line 15603 OMC_FILE
15604  goto tmp2_done;
15605  }
15606  case 3: {
15607  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
15608  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15609 
15610  _n = tmpMeta[1];
15611  /* Pattern matching succeeded */
15612 #line 3003 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15613  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _n);
15614 #line 3003 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15615  tmpMeta[0] = tmpMeta[1];
15616 #line 15616 OMC_FILE
15617  goto tmp2_done;
15618  }
15619  case 5: {
15620  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
15621  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15622  _outPath = tmpMeta[1];
15623  /* Pattern matching succeeded */
15624 #line 3004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15625  /* Tail recursive call */
15626 #line 3004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15627  _inPath = _outPath;
15628 #line 3004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15629  goto _tailrecursive;
15630 #line 3004 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15631  /* TODO: Make sure any eventual dead code below is never generated */
15632 #line 15632 OMC_FILE
15633  goto tmp2_done;
15634  }
15635  }
15636  goto tmp2_end;
15637  tmp2_end: ;
15638  }
15639  goto goto_1;
15640  goto_1:;
15641  MMC_THROW_INTERNAL();
15642  goto tmp2_done;
15643  tmp2_done:;
15644  }
15645  }
15646  _outPath = tmpMeta[0];
15647  _return: OMC_LABEL_UNUSED
15648  return _outPath;
15649 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathGe()

DLLExport modelica_boolean omc_Absyn_pathGe ( threadData_t threadData,
modelica_metatype  _path1,
modelica_metatype  _path2 
)

Definition at line 6017 of file Absyn.c.

6018 {
6019  modelica_boolean _ge;
6020  MMC_SO();
6021  _tailrecursive: OMC_LABEL_UNUSED
6022 #line 5485 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6023  _ge = (!omc_Absyn_pathLt(threadData, _path1, _path2));
6024 #line 6024 OMC_FILE
6025  _return: OMC_LABEL_UNUSED
6026  return _ge;
6027 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathLt(threadData_t *threadData, modelica_metatype _path1, modelica_metatype _path2)
Definition: Absyn.c:6038
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathHashMod()

DLLExport modelica_integer omc_Absyn_pathHashMod ( threadData_t threadData,
modelica_metatype  _path,
modelica_integer  _mod 
)

Definition at line 16346 of file Absyn.c.

16347 {
16348  modelica_integer _hash;
16349  MMC_SO();
16350  _tailrecursive: OMC_LABEL_UNUSED
16351 #line 2811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16352  _hash = labs(modelica_integer_mod(omc_Absyn_pathHashModWork(threadData, _path, ((modelica_integer) 5381)), (modelica_integer)_mod));
16353 #line 16353 OMC_FILE
16354  _return: OMC_LABEL_UNUSED
16355  return _hash;
16356 }
m_integer modelica_integer
DLLExport modelica_integer omc_Absyn_pathHashModWork(threadData_t *threadData, modelica_metatype _path, modelica_integer _acc)
Definition: Absyn.c:16238
Here is the caller graph for this function:

◆ omc_Absyn_pathHashModWork()

DLLExport modelica_integer omc_Absyn_pathHashModWork ( threadData_t threadData,
modelica_metatype  _path,
modelica_integer  _acc 
)

Definition at line 16238 of file Absyn.c.

16239 {
16240  modelica_integer _hash;
16241  modelica_integer tmp1 = 0;
16242  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
16243  MMC_SO();
16244  _tailrecursive: OMC_LABEL_UNUSED
16245 #line 16245 OMC_FILE
16246  { /* match expression */
16247  modelica_metatype tmp4_1;
16248  tmp4_1 = _path;
16249  {
16250  modelica_metatype _p = NULL;
16251  modelica_string _s = NULL;
16252  modelica_integer _i;
16253  modelica_integer _i2;
16254  int tmp4;
16255  {
16256  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
16257  case 5: {
16258  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
16259  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16260  _p = tmpMeta[0];
16261  /* Pattern matching succeeded */
16262 #line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16263  /* Tail recursive call */
16264 #line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16265  _path = _p;
16266 #line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16267  _acc = ((modelica_integer) 46) + (((modelica_integer) 31)) * ((modelica_integer)_acc);
16268 #line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16269  goto _tailrecursive;
16270 #line 2824 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16271  /* TODO: Make sure any eventual dead code below is never generated */
16272 #line 16272 OMC_FILE
16273  goto tmp3_done;
16274  }
16275  case 3: {
16276  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
16277  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16278  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
16279  _s = tmpMeta[0];
16280  _p = tmpMeta[1];
16281  /* Pattern matching succeeded */
16282 #line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16283  _i = stringHashDjb2(_s);
16284 #line 16284 OMC_FILE
16285 
16286 #line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16287  _i2 = ((modelica_integer) 46) + (((modelica_integer) 31)) * ((modelica_integer)_acc);
16288 #line 16288 OMC_FILE
16289 #line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16290  /* Tail recursive call */
16291 #line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16292  _path = _p;
16293 #line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16294  _acc = (((modelica_integer) 31)) * ((modelica_integer)_i2) + (modelica_integer)_i;
16295 #line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16296  goto _tailrecursive;
16297 #line 2825 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16298  /* TODO: Make sure any eventual dead code below is never generated */
16299 #line 16299 OMC_FILE
16300  goto tmp3_done;
16301  }
16302  case 4: {
16303  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
16304  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
16305  _s = tmpMeta[0];
16306  /* Pattern matching succeeded */
16307 #line 2826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16308  _i = stringHashDjb2(_s);
16309 #line 16309 OMC_FILE
16310 
16311 #line 2826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16312  _i2 = ((modelica_integer) 46) + (((modelica_integer) 31)) * ((modelica_integer)_acc);
16313 #line 16313 OMC_FILE
16314 #line 2826 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16315  tmp1 = (((modelica_integer) 31)) * ((modelica_integer)_i2) + (modelica_integer)_i;
16316 #line 16316 OMC_FILE
16317  goto tmp3_done;
16318  }
16319  }
16320  goto tmp3_end;
16321  tmp3_end: ;
16322  }
16323  goto goto_2;
16324  goto_2:;
16325  MMC_THROW_INTERNAL();
16326  goto tmp3_done;
16327  tmp3_done:;
16328  }
16329  }
16330  _hash = tmp1;
16331  _return: OMC_LABEL_UNUSED
16332  return _hash;
16333 }
modelica_integer stringHashDjb2(metamodelica_string_const s)
modelica_metatype modelica_string
m_integer modelica_integer
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathIsFullyQualified()

DLLExport modelica_boolean omc_Absyn_pathIsFullyQualified ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 7476 of file Absyn.c.

7477 {
7478  modelica_boolean _outIsQualified;
7479  modelica_boolean tmp1 = 0;
7480  MMC_SO();
7481  _tailrecursive: OMC_LABEL_UNUSED
7482 #line 7482 OMC_FILE
7483  { /* match expression */
7484  modelica_metatype tmp4_1;
7485  tmp4_1 = _inPath;
7486  {
7487  volatile mmc_switch_type tmp4;
7488  int tmp5;
7489  tmp4 = 0;
7490  for (; tmp4 < 2; tmp4++) {
7491  switch (MMC_SWITCH_CAST(tmp4)) {
7492  case 0: {
7493  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
7494 
7495  /* Pattern matching succeeded */
7496 #line 5167 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7497  tmp1 = 1;
7498 #line 7498 OMC_FILE
7499  goto tmp3_done;
7500  }
7501  case 1: {
7502 
7503  /* Pattern matching succeeded */
7504 #line 5168 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7505  tmp1 = 0;
7506 #line 7506 OMC_FILE
7507  goto tmp3_done;
7508  }
7509  }
7510  goto tmp3_end;
7511  tmp3_end: ;
7512  }
7513  goto goto_2;
7514  goto_2:;
7515  MMC_THROW_INTERNAL();
7516  goto tmp3_done;
7517  tmp3_done:;
7518  }
7519  }
7520  _outIsQualified = tmp1;
7521  _return: OMC_LABEL_UNUSED
7522  return _outIsQualified;
7523 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_pathIsIdent()

DLLExport modelica_boolean omc_Absyn_pathIsIdent ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 7418 of file Absyn.c.

7419 {
7420  modelica_boolean _outIsIdent;
7421  modelica_boolean tmp1 = 0;
7422  MMC_SO();
7423  _tailrecursive: OMC_LABEL_UNUSED
7424 #line 7424 OMC_FILE
7425  { /* match expression */
7426  modelica_metatype tmp4_1;
7427  tmp4_1 = _inPath;
7428  {
7429  volatile mmc_switch_type tmp4;
7430  int tmp5;
7431  tmp4 = 0;
7432  for (; tmp4 < 2; tmp4++) {
7433  switch (MMC_SWITCH_CAST(tmp4)) {
7434  case 0: {
7435  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
7436 
7437  /* Pattern matching succeeded */
7438 #line 5177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7439  tmp1 = 1;
7440 #line 7440 OMC_FILE
7441  goto tmp3_done;
7442  }
7443  case 1: {
7444 
7445  /* Pattern matching succeeded */
7446 #line 5178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7447  tmp1 = 0;
7448 #line 7448 OMC_FILE
7449  goto tmp3_done;
7450  }
7451  }
7452  goto tmp3_end;
7453  tmp3_end: ;
7454  }
7455  goto goto_2;
7456  goto_2:;
7457  MMC_THROW_INTERNAL();
7458  goto tmp3_done;
7459  tmp3_done:;
7460  }
7461  }
7462  _outIsIdent = tmp1;
7463  _return: OMC_LABEL_UNUSED
7464  return _outIsIdent;
7465 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_pathIsQual()

DLLExport modelica_boolean omc_Absyn_pathIsQual ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 7360 of file Absyn.c.

7361 {
7362  modelica_boolean _outIsQual;
7363  modelica_boolean tmp1 = 0;
7364  MMC_SO();
7365  _tailrecursive: OMC_LABEL_UNUSED
7366 #line 7366 OMC_FILE
7367  { /* match expression */
7368  modelica_metatype tmp4_1;
7369  tmp4_1 = _inPath;
7370  {
7371  volatile mmc_switch_type tmp4;
7372  int tmp5;
7373  tmp4 = 0;
7374  for (; tmp4 < 2; tmp4++) {
7375  switch (MMC_SWITCH_CAST(tmp4)) {
7376  case 0: {
7377  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
7378 
7379  /* Pattern matching succeeded */
7380 #line 5187 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7381  tmp1 = 1;
7382 #line 7382 OMC_FILE
7383  goto tmp3_done;
7384  }
7385  case 1: {
7386 
7387  /* Pattern matching succeeded */
7388 #line 5188 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7389  tmp1 = 0;
7390 #line 7390 OMC_FILE
7391  goto tmp3_done;
7392  }
7393  }
7394  goto tmp3_end;
7395  tmp3_end: ;
7396  }
7397  goto goto_2;
7398  goto_2:;
7399  MMC_THROW_INTERNAL();
7400  goto tmp3_done;
7401  tmp3_done:;
7402  }
7403  }
7404  _outIsQual = tmp1;
7405  _return: OMC_LABEL_UNUSED
7406  return _outIsQual;
7407 }
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_pathLast()

DLLExport modelica_metatype omc_Absyn_pathLast ( threadData_t threadData,
modelica_metatype $in_path 
)

Definition at line 15723 of file Absyn.c.

15724 {
15725  modelica_metatype _path = NULL;
15726  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
15727  MMC_SO();
15728  _tailrecursive: OMC_LABEL_UNUSED
15729  _path = _$in_path;
15730 #line 15730 OMC_FILE
15731  { /* match expression */
15732  modelica_metatype tmp3_1;
15733  tmp3_1 = _path;
15734  {
15735  modelica_metatype _p = NULL;
15736  int tmp3;
15737  {
15738  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
15739  case 3: {
15740  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
15741  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
15742  _p = tmpMeta[1];
15743  /* Pattern matching succeeded */
15744 #line 2973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15745  /* Tail recursive call */
15746 #line 2973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15747  _$in_path = _p;
15748 #line 2973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15749  goto _tailrecursive;
15750 #line 2973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15751  /* TODO: Make sure any eventual dead code below is never generated */
15752 #line 15752 OMC_FILE
15753  goto tmp2_done;
15754  }
15755  case 4: {
15756 
15757  /* Pattern matching succeeded */
15758 #line 2974 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15759  tmpMeta[0] = _path;
15760 #line 15760 OMC_FILE
15761  goto tmp2_done;
15762  }
15763  case 5: {
15764  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
15765  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15766  _p = tmpMeta[1];
15767  /* Pattern matching succeeded */
15768 #line 2975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15769  /* Tail recursive call */
15770 #line 2975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15771  _$in_path = _p;
15772 #line 2975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15773  goto _tailrecursive;
15774 #line 2975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15775  /* TODO: Make sure any eventual dead code below is never generated */
15776 #line 15776 OMC_FILE
15777  goto tmp2_done;
15778  }
15779  }
15780  goto tmp2_end;
15781  tmp2_end: ;
15782  }
15783  goto goto_1;
15784  goto_1:;
15785  MMC_THROW_INTERNAL();
15786  goto tmp2_done;
15787  tmp2_done:;
15788  }
15789  }
15790  _path = tmpMeta[0];
15791  _return: OMC_LABEL_UNUSED
15792  return _path;
15793 }
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_pathLastIdent()

DLLExport modelica_string omc_Absyn_pathLastIdent ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 15796 of file Absyn.c.

15797 {
15798  modelica_string _outIdent = NULL;
15799  modelica_string tmp1 = 0;
15800  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
15801  MMC_SO();
15802  _tailrecursive: OMC_LABEL_UNUSED
15803 #line 15803 OMC_FILE
15804  { /* match expression */
15805  modelica_metatype tmp4_1;
15806  tmp4_1 = _inPath;
15807  {
15808  modelica_string _id = NULL;
15809  modelica_metatype _p = NULL;
15810  int tmp4;
15811  {
15812  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
15813  case 3: {
15814  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
15815  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
15816  _p = tmpMeta[0];
15817  /* Pattern matching succeeded */
15818 #line 2960 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15819  /* Tail recursive call */
15820 #line 2960 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15821  _inPath = _p;
15822 #line 2960 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15823  goto _tailrecursive;
15824 #line 2960 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15825  /* TODO: Make sure any eventual dead code below is never generated */
15826 #line 15826 OMC_FILE
15827  goto tmp3_done;
15828  }
15829  case 4: {
15830  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
15831  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
15832  _id = tmpMeta[0];
15833  /* Pattern matching succeeded */
15834 #line 2961 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15835  tmp1 = _id;
15836 #line 15836 OMC_FILE
15837  goto tmp3_done;
15838  }
15839  case 5: {
15840  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
15841  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
15842  _p = tmpMeta[0];
15843  /* Pattern matching succeeded */
15844 #line 2962 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15845  /* Tail recursive call */
15846 #line 2962 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15847  _inPath = _p;
15848 #line 2962 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15849  goto _tailrecursive;
15850 #line 2962 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15851  /* TODO: Make sure any eventual dead code below is never generated */
15852 #line 15852 OMC_FILE
15853  goto tmp3_done;
15854  }
15855  }
15856  goto tmp3_end;
15857  tmp3_end: ;
15858  }
15859  goto goto_2;
15860  goto_2:;
15861  MMC_THROW_INTERNAL();
15862  goto tmp3_done;
15863  tmp3_done:;
15864  }
15865  }
15866  _outIdent = tmp1;
15867  _return: OMC_LABEL_UNUSED
15868  return _outIdent;
15869 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathLt()

DLLExport modelica_boolean omc_Absyn_pathLt ( threadData_t threadData,
modelica_metatype  _path1,
modelica_metatype  _path2 
)

Definition at line 6038 of file Absyn.c.

6039 {
6040  modelica_boolean _lt;
6041  MMC_SO();
6042  _tailrecursive: OMC_LABEL_UNUSED
6043 #line 5477 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
6044  _lt = (stringCompare(omc_Absyn_pathString(threadData, _path1, _OMC_LIT1, 1, 0), omc_Absyn_pathString(threadData, _path2, _OMC_LIT1, 1, 0)) < ((modelica_integer) 0));
6045 #line 6045 OMC_FILE
6046  _return: OMC_LABEL_UNUSED
6047  return _lt;
6048 }
m_integer modelica_integer
signed char modelica_boolean
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathPartCount()

DLLExport modelica_integer omc_Absyn_pathPartCount ( threadData_t threadData,
modelica_metatype  _path,
modelica_integer  _partsAccum 
)

Definition at line 329 of file Absyn.c.

330 {
331  modelica_integer _parts;
332  modelica_integer tmp1 = 0;
333  MMC_SO();
334  _tailrecursive: OMC_LABEL_UNUSED
335 #line 335 OMC_FILE
336  { /* match expression */
337  modelica_metatype tmp4_1;
338  tmp4_1 = _path;
339  {
340  int tmp4;
341  {
342  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
343  case 4: {
344 
345  /* Pattern matching succeeded */
346 #line 6868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
347  tmp1 = ((modelica_integer) 1) + (modelica_integer)_partsAccum;
348 #line 348 OMC_FILE
349  goto tmp3_done;
350  }
351  case 3: {
352 
353  /* Pattern matching succeeded */
354 #line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
355  /* Tail recursive call */
356 #line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
357  _path = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_path), 3)));
358 #line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
359  _partsAccum = ((modelica_integer) 1) + (modelica_integer)_partsAccum;
360 #line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
361  goto _tailrecursive;
362 #line 6869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
363  /* TODO: Make sure any eventual dead code below is never generated */
364 #line 364 OMC_FILE
365  goto tmp3_done;
366  }
367  case 5: {
368 
369  /* Pattern matching succeeded */
370 #line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
371  /* Tail recursive call */
372 #line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
373  _path = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_path), 2)));
374 #line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
375  _partsAccum = (modelica_integer)_partsAccum;
376 #line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
377  goto _tailrecursive;
378 #line 6870 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
379  /* TODO: Make sure any eventual dead code below is never generated */
380 #line 380 OMC_FILE
381  goto tmp3_done;
382  }
383  }
384  goto tmp3_end;
385  tmp3_end: ;
386  }
387  goto goto_2;
388  goto_2:;
389  MMC_THROW_INTERNAL();
390  goto tmp3_done;
391  tmp3_done:;
392  }
393  }
394  _parts = tmp1;
395  _return: OMC_LABEL_UNUSED
396  return _parts;
397 }
m_integer modelica_integer
void * modelica_metatype
Here is the caller graph for this function:

◆ omc_Absyn_pathPrefix()

DLLExport modelica_metatype omc_Absyn_pathPrefix ( threadData_t threadData,
modelica_metatype  _path 
)

Definition at line 15277 of file Absyn.c.

15278 {
15279  modelica_metatype _prefix = NULL;
15280  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
15281  MMC_SO();
15282  _tailrecursive: OMC_LABEL_UNUSED
15283 #line 15283 OMC_FILE
15284  { /* matchcontinue expression */
15285  volatile modelica_metatype tmp3_1;
15286  tmp3_1 = _path;
15287  {
15288  modelica_metatype _p = NULL;
15289  modelica_string _n = NULL;
15290  volatile mmc_switch_type tmp3;
15291  int tmp4;
15292  tmp3 = 0;
15293  MMC_TRY_INTERNAL(mmc_jumper)
15294  tmp2_top:
15295  threadData->mmc_jumper = &new_mmc_jumper;
15296  for (; tmp3 < 3; tmp3++) {
15297  switch (MMC_SWITCH_CAST(tmp3)) {
15298  case 0: {
15299  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
15300  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15301  _p = tmpMeta[1];
15302  tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
15303 #line 3069 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15304  tmpMeta[0] = omc_Absyn_pathPrefix(threadData, _p);
15305 #line 15305 OMC_FILE
15306  goto tmp2_done;
15307  }
15308  case 1: {
15309  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
15310  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15311  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
15312  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],1,1) == 0) goto tmp2_end;
15313 
15314  _n = tmpMeta[1];
15315  /* Pattern matching succeeded */
15316 #line 3070 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15317  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _n);
15318 #line 3070 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15319  tmpMeta[0] = tmpMeta[1];
15320 #line 15320 OMC_FILE
15321  goto tmp2_done;
15322  }
15323  case 2: {
15324  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
15325  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15326  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
15327  _n = tmpMeta[1];
15328  _p = tmpMeta[2];
15329  /* Pattern matching succeeded */
15330 #line 3073 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15331  _p = omc_Absyn_pathPrefix(threadData, _p);
15332 #line 15332 OMC_FILE
15333 #line 3074 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15334  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _n, _p);
15335 #line 3074 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15336  tmpMeta[0] = tmpMeta[1];
15337 #line 15337 OMC_FILE
15338  goto tmp2_done;
15339  }
15340  }
15341  goto tmp2_end;
15342  tmp2_end: ;
15343  }
15344  goto goto_1;
15345  tmp2_done:
15346  (void)tmp3;
15347  MMC_RESTORE_INTERNAL(mmc_jumper);
15348  goto tmp2_done2;
15349  goto_1:;
15350  MMC_CATCH_INTERNAL(mmc_jumper);
15351  if (++tmp3 < 3) {
15352  goto tmp2_top;
15353  }
15354  MMC_THROW_INTERNAL();
15355  tmp2_done2:;
15356  }
15357  }
15358  _prefix = tmpMeta[0];
15359  _return: OMC_LABEL_UNUSED
15360  return _prefix;
15361 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
DLLExport modelica_metatype omc_Absyn_pathPrefix(threadData_t *threadData, modelica_metatype _path)
Definition: Absyn.c:15277
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathPrefixOf()

DLLExport modelica_boolean omc_Absyn_pathPrefixOf ( threadData_t threadData,
modelica_metatype  _prefixPath,
modelica_metatype  _path 
)

Definition at line 14548 of file Absyn.c.

14549 {
14550  modelica_boolean _isPrefix;
14551  modelica_boolean tmp1 = 0;
14552  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
14553  MMC_SO();
14554  _tailrecursive: OMC_LABEL_UNUSED
14555 #line 14555 OMC_FILE
14556  { /* matchcontinue expression */
14557  volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
14558  tmp4_1 = _prefixPath;
14559  tmp4_2 = _path;
14560  {
14561  modelica_metatype _p = NULL;
14562  modelica_metatype _p2 = NULL;
14563  modelica_string _id = NULL;
14564  modelica_string _id2 = NULL;
14565  volatile mmc_switch_type tmp4;
14566  int tmp5;
14567  tmp4 = 0;
14568  MMC_TRY_INTERNAL(mmc_jumper)
14569  tmp3_top:
14570  threadData->mmc_jumper = &new_mmc_jumper;
14571  for (; tmp4 < 6; tmp4++) {
14572  switch (MMC_SWITCH_CAST(tmp4)) {
14573  case 0: {
14574  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
14575  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
14576 
14577  _p = tmpMeta[0];
14578  _p2 = tmp4_2;
14579  /* Pattern matching succeeded */
14580 #line 3271 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14581  tmp1 = omc_Absyn_pathPrefixOf(threadData, _p, _p2);
14582 #line 14582 OMC_FILE
14583  goto tmp3_done;
14584  }
14585  case 1: {
14586  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,2,1) == 0) goto tmp3_end;
14587  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
14588 
14589  _p2 = tmpMeta[0];
14590  _p = tmp4_1;
14591  tmp4 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
14592 #line 3272 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14593  tmp1 = omc_Absyn_pathPrefixOf(threadData, _p, _p2);
14594 #line 14594 OMC_FILE
14595  goto tmp3_done;
14596  }
14597  case 2: {
14598  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
14599  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
14600  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
14601  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
14602  _id = tmpMeta[0];
14603  _id2 = tmpMeta[1];
14604  tmp4 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
14605 #line 3273 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14606  tmp1 = (stringEqual(_id, _id2));
14607 #line 14607 OMC_FILE
14608  goto tmp3_done;
14609  }
14610  case 3: {
14611  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
14612  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
14613  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
14614  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
14615 
14616  _id = tmpMeta[0];
14617  _id2 = tmpMeta[1];
14618  tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
14619 #line 3274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14620  tmp1 = (stringEqual(_id, _id2));
14621 #line 14621 OMC_FILE
14622  goto tmp3_done;
14623  }
14624  case 4: {
14625  modelica_boolean tmp6;
14626  modelica_boolean tmp7;
14627  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
14628  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
14629  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
14630  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
14631  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
14632  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
14633  _id = tmpMeta[0];
14634  _p = tmpMeta[1];
14635  _id2 = tmpMeta[2];
14636  _p2 = tmpMeta[3];
14637  /* Pattern matching succeeded */
14638 #line 3277 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14639  /* Pattern-matching assignment */
14640 #line 3277 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14641  tmp6 = (stringEqual(_id, _id2));
14642 #line 3277 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14643  if (1 != tmp6) goto goto_2;
14644 #line 14644 OMC_FILE
14645 
14646 #line 3278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14647  /* Pattern-matching assignment */
14648 #line 3278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14649  tmp7 = omc_Absyn_pathPrefixOf(threadData, _p, _p2);
14650 #line 3278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14651  if (1 != tmp7) goto goto_2;
14652 #line 14652 OMC_FILE
14653 #line 3279 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14654  tmp1 = 1;
14655 #line 14655 OMC_FILE
14656  goto tmp3_done;
14657  }
14658  case 5: {
14659 
14660  /* Pattern matching succeeded */
14661 #line 3281 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14662  tmp1 = 0;
14663 #line 14663 OMC_FILE
14664  goto tmp3_done;
14665  }
14666  }
14667  goto tmp3_end;
14668  tmp3_end: ;
14669  }
14670  goto goto_2;
14671  tmp3_done:
14672  (void)tmp4;
14673  MMC_RESTORE_INTERNAL(mmc_jumper);
14674  goto tmp3_done2;
14675  goto_2:;
14676  MMC_CATCH_INTERNAL(mmc_jumper);
14677  if (++tmp4 < 6) {
14678  goto tmp3_top;
14679  }
14680  MMC_THROW_INTERNAL();
14681  tmp3_done2:;
14682  }
14683  }
14684  _isPrefix = tmp1;
14685  _return: OMC_LABEL_UNUSED
14686  return _isPrefix;
14687 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_Absyn_pathPrefixOf(threadData_t *threadData, modelica_metatype _prefixPath, modelica_metatype _path)
Definition: Absyn.c:14548
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathReplaceFirstIdent()

DLLExport modelica_metatype omc_Absyn_pathReplaceFirstIdent ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _replPath 
)

Definition at line 14857 of file Absyn.c.

14858 {
14859  modelica_metatype _outPath = NULL;
14860  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
14861  MMC_SO();
14862  _tailrecursive: OMC_LABEL_UNUSED
14863 #line 14863 OMC_FILE
14864  { /* match expression */
14865  modelica_metatype tmp3_1;
14866  tmp3_1 = _path;
14867  {
14868  modelica_metatype _p = NULL;
14869  volatile mmc_switch_type tmp3;
14870  int tmp4;
14871  tmp3 = 0;
14872  for (; tmp3 < 2; tmp3++) {
14873  switch (MMC_SWITCH_CAST(tmp3)) {
14874  case 0: {
14875  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
14876  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
14877  _p = tmpMeta[1];
14878  /* Pattern matching succeeded */
14879 #line 3198 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14880  tmpMeta[0] = omc_Absyn_joinPaths(threadData, _replPath, _p);
14881 #line 14881 OMC_FILE
14882  goto tmp2_done;
14883  }
14884  case 1: {
14885  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
14886 
14887  /* Pattern matching succeeded */
14888 #line 3199 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14889  tmpMeta[0] = _replPath;
14890 #line 14890 OMC_FILE
14891  goto tmp2_done;
14892  }
14893  }
14894  goto tmp2_end;
14895  tmp2_end: ;
14896  }
14897  goto goto_1;
14898  goto_1:;
14899  MMC_THROW_INTERNAL();
14900  goto tmp2_done;
14901  tmp2_done:;
14902  }
14903  }
14904  _outPath = tmpMeta[0];
14905  _return: OMC_LABEL_UNUSED
14906  return _outPath;
14907 }
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_joinPaths(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:12781
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_pathReplaceIdent()

DLLExport modelica_metatype omc_Absyn_pathReplaceIdent ( threadData_t threadData,
modelica_metatype  _path,
modelica_string  _last 
)

Definition at line 8849 of file Absyn.c.

8850 {
8851  modelica_metatype _out = NULL;
8852  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
8853  MMC_SO();
8854  _tailrecursive: OMC_LABEL_UNUSED
8855 #line 8855 OMC_FILE
8856  { /* match expression */
8857  modelica_metatype tmp3_1;modelica_string tmp3_2;
8858  tmp3_1 = _path;
8859  tmp3_2 = _last;
8860  {
8861  modelica_metatype _p = NULL;
8862  modelica_string _n = NULL;
8863  modelica_string _s = NULL;
8864  int tmp3;
8865  {
8866  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
8867  case 5: {
8868  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
8869  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
8870 
8871  _p = tmpMeta[1];
8872  _s = tmp3_2;
8873  /* Pattern matching succeeded */
8874 #line 4816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8875  _p = omc_Absyn_pathReplaceIdent(threadData, _p, _s);
8876 #line 8876 OMC_FILE
8877 #line 4816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8878  tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
8879 #line 4816 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8880  tmpMeta[0] = tmpMeta[1];
8881 #line 8881 OMC_FILE
8882  goto tmp2_done;
8883  }
8884  case 3: {
8885  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
8886  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
8887  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
8888 
8889  _n = tmpMeta[1];
8890  _p = tmpMeta[2];
8891  _s = tmp3_2;
8892  /* Pattern matching succeeded */
8893 #line 4817 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8894  _p = omc_Absyn_pathReplaceIdent(threadData, _p, _s);
8895 #line 8895 OMC_FILE
8896 #line 4817 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8897  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _n, _p);
8898 #line 4817 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8899  tmpMeta[0] = tmpMeta[1];
8900 #line 8900 OMC_FILE
8901  goto tmp2_done;
8902  }
8903  case 4: {
8904  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
8905 
8906  _s = tmp3_2;
8907  /* Pattern matching succeeded */
8908 #line 4818 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8909  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s);
8910 #line 4818 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
8911  tmpMeta[0] = tmpMeta[1];
8912 #line 8912 OMC_FILE
8913  goto tmp2_done;
8914  }
8915  }
8916  goto tmp2_end;
8917  tmp2_end: ;
8918  }
8919  goto goto_1;
8920  goto_1:;
8921  MMC_THROW_INTERNAL();
8922  goto tmp2_done;
8923  tmp2_done:;
8924  }
8925  }
8926  _out = tmpMeta[0];
8927  _return: OMC_LABEL_UNUSED
8928  return _out;
8929 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_FULLYQUALIFIED__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_pathReplaceIdent(threadData_t *threadData, modelica_metatype _path, modelica_string _last)
Definition: Absyn.c:8849
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathRest()

DLLExport modelica_metatype omc_Absyn_pathRest ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 15447 of file Absyn.c.

15448 {
15449  modelica_metatype _outPath = NULL;
15450  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
15451  MMC_SO();
15452  _tailrecursive: OMC_LABEL_UNUSED
15453 #line 15453 OMC_FILE
15454  { /* match expression */
15455  modelica_metatype tmp3_1;
15456  tmp3_1 = _inPath;
15457  {
15458  volatile mmc_switch_type tmp3;
15459  int tmp4;
15460  tmp3 = 0;
15461  for (; tmp3 < 2; tmp3++) {
15462  switch (MMC_SWITCH_CAST(tmp3)) {
15463  case 0: {
15464  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
15465  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
15466  _outPath = tmpMeta[1];
15467  /* Pattern matching succeeded */
15468 #line 3029 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15469  tmpMeta[0] = _outPath;
15470 #line 15470 OMC_FILE
15471  goto tmp2_done;
15472  }
15473  case 1: {
15474  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
15475  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15476  _outPath = tmpMeta[1];
15477  /* Pattern matching succeeded */
15478 #line 3030 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15479  /* Tail recursive call */
15480 #line 3030 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15481  _inPath = _outPath;
15482 #line 3030 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15483  goto _tailrecursive;
15484 #line 3030 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15485  /* TODO: Make sure any eventual dead code below is never generated */
15486 #line 15486 OMC_FILE
15487  goto tmp2_done;
15488  }
15489  }
15490  goto tmp2_end;
15491  tmp2_end: ;
15492  }
15493  goto goto_1;
15494  goto_1:;
15495  MMC_THROW_INTERNAL();
15496  goto tmp2_done;
15497  tmp2_done:;
15498  }
15499  }
15500  _outPath = tmpMeta[0];
15501  _return: OMC_LABEL_UNUSED
15502  return _outPath;
15503 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathSecondIdent()

DLLExport modelica_string omc_Absyn_pathSecondIdent ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 15506 of file Absyn.c.

15507 {
15508  modelica_string _outIdent = NULL;
15509  modelica_string tmp1 = 0;
15510  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
15511  MMC_SO();
15512  _tailrecursive: OMC_LABEL_UNUSED
15513 #line 15513 OMC_FILE
15514  { /* match expression */
15515  modelica_metatype tmp4_1;
15516  tmp4_1 = _inPath;
15517  {
15518  modelica_string _n = NULL;
15519  modelica_metatype _p = NULL;
15520  volatile mmc_switch_type tmp4;
15521  int tmp5;
15522  tmp4 = 0;
15523  for (; tmp4 < 3; tmp4++) {
15524  switch (MMC_SWITCH_CAST(tmp4)) {
15525  case 0: {
15526  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
15527  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
15528  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,2) == 0) goto tmp3_end;
15529  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
15530 
15531  _n = tmpMeta[1];
15532  /* Pattern matching succeeded */
15533 #line 3017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15534  tmp1 = _n;
15535 #line 15535 OMC_FILE
15536  goto tmp3_done;
15537  }
15538  case 1: {
15539  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
15540  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
15541  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],1,1) == 0) goto tmp3_end;
15542  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
15543  _n = tmpMeta[1];
15544  /* Pattern matching succeeded */
15545 #line 3018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15546  tmp1 = _n;
15547 #line 15547 OMC_FILE
15548  goto tmp3_done;
15549  }
15550  case 2: {
15551  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
15552  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
15553  _p = tmpMeta[0];
15554  /* Pattern matching succeeded */
15555 #line 3019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15556  /* Tail recursive call */
15557 #line 3019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15558  _inPath = _p;
15559 #line 3019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15560  goto _tailrecursive;
15561 #line 3019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15562  /* TODO: Make sure any eventual dead code below is never generated */
15563 #line 15563 OMC_FILE
15564  goto tmp3_done;
15565  }
15566  }
15567  goto tmp3_end;
15568  tmp3_end: ;
15569  }
15570  goto goto_2;
15571  goto_2:;
15572  MMC_THROW_INTERNAL();
15573  goto tmp3_done;
15574  tmp3_done:;
15575  }
15576  }
15577  _outIdent = tmp1;
15578  _return: OMC_LABEL_UNUSED
15579  return _outIdent;
15580 }
modelica_metatype modelica_string
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathSetLastIdent()

DLLExport modelica_metatype omc_Absyn_pathSetLastIdent ( threadData_t threadData,
modelica_metatype  _inPath,
modelica_metatype  _inLastIdent 
)

Definition at line 5279 of file Absyn.c.

5280 {
5281  modelica_metatype _outPath = NULL;
5282  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
5283  MMC_SO();
5284  _tailrecursive: OMC_LABEL_UNUSED
5285 #line 5285 OMC_FILE
5286  { /* match expression */
5287  modelica_metatype tmp3_1;
5288  tmp3_1 = _inPath;
5289  {
5290  modelica_metatype _p = NULL;
5291  modelica_string _n = NULL;
5292  int tmp3;
5293  {
5294  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
5295  case 4: {
5296 
5297  /* Pattern matching succeeded */
5298 #line 5647 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5299  tmpMeta[0] = _inLastIdent;
5300 #line 5300 OMC_FILE
5301  goto tmp2_done;
5302  }
5303  case 3: {
5304  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
5305  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5306  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
5307  _n = tmpMeta[1];
5308  _p = tmpMeta[2];
5309  /* Pattern matching succeeded */
5310 #line 5651 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5311  _p = omc_Absyn_pathSetLastIdent(threadData, _p, _inLastIdent);
5312 #line 5312 OMC_FILE
5313 #line 5652 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5314  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _n, _p);
5315 #line 5652 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5316  tmpMeta[0] = tmpMeta[1];
5317 #line 5317 OMC_FILE
5318  goto tmp2_done;
5319  }
5320  case 5: {
5321  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
5322  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5323  _p = tmpMeta[1];
5324  /* Pattern matching succeeded */
5325 #line 5657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5326  _p = omc_Absyn_pathSetLastIdent(threadData, _p, _inLastIdent);
5327 #line 5327 OMC_FILE
5328 #line 5658 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5329  tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
5330 #line 5658 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5331  tmpMeta[0] = tmpMeta[1];
5332 #line 5332 OMC_FILE
5333  goto tmp2_done;
5334  }
5335  }
5336  goto tmp2_end;
5337  tmp2_end: ;
5338  }
5339  goto goto_1;
5340  goto_1:;
5341  MMC_THROW_INTERNAL();
5342  goto tmp2_done;
5343  tmp2_done:;
5344  }
5345  }
5346  _outPath = tmpMeta[0];
5347  _return: OMC_LABEL_UNUSED
5348  return _outPath;
5349 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_FULLYQUALIFIED__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
DLLExport modelica_metatype omc_Absyn_pathSetLastIdent(threadData_t *threadData, modelica_metatype _inPath, modelica_metatype _inLastIdent)
Definition: Absyn.c:5279
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathString()

DLLExport modelica_string omc_Absyn_pathString ( threadData_t threadData,
modelica_metatype  _path,
modelica_string  _delimiter,
modelica_boolean  _usefq,
modelica_boolean  _reverse 
)

Definition at line 17021 of file Absyn.c.

17022 {
17023  modelica_string _s = NULL;
17024  modelica_metatype _p1 = NULL;
17025  modelica_metatype _p2 = NULL;
17026  modelica_integer _count;
17027  modelica_integer _len;
17028  modelica_integer _dlen;
17029  modelica_boolean _b;
17030  modelica_integer tmp5_c1 __attribute__((unused)) = 0;
17031  modelica_integer tmp5_c2 __attribute__((unused)) = 0;
17032  modelica_boolean tmp5_c3 __attribute__((unused)) = 0;
17033  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
17034  MMC_SO();
17035  _tailrecursive: OMC_LABEL_UNUSED
17036  _count = ((modelica_integer) 0);
17037  _len = ((modelica_integer) 0);
17038  _dlen = stringLength(_delimiter);
17039 #line 2672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17040  _p1 = (_usefq?_path:omc_Absyn_makeNotFullyQualified(threadData, _path));
17041 #line 17041 OMC_FILE
17042 
17043 #line 17043 OMC_FILE
17044  { /* match expression */
17045  modelica_metatype tmp3_1;
17046  tmp3_1 = _p1;
17047  {
17048  volatile mmc_switch_type tmp3;
17049  int tmp4;
17050  tmp3 = 0;
17051  for (; tmp3 < 2; tmp3++) {
17052  switch (MMC_SWITCH_CAST(tmp3)) {
17053  case 0: {
17054  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
17055 
17056  /* Pattern matching succeeded */
17057 #line 2677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17058  _s = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p1), 2)));
17059 #line 17059 OMC_FILE
17060 
17061 #line 2678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17062  goto _return;
17063 #line 17063 OMC_FILE
17064 #line 17064 OMC_FILE
17065  goto tmp2_done;
17066  }
17067  case 1: {
17068 
17069  /* Pattern matching succeeded */
17070 #line 17070 OMC_FILE
17071  goto tmp2_done;
17072  }
17073  }
17074  goto tmp2_end;
17075  tmp2_end: ;
17076  }
17077  goto goto_1;
17078  goto_1:;
17079  MMC_THROW_INTERNAL();
17080  goto tmp2_done;
17081  tmp2_done:;
17082  }
17083  }
17084  ;
17085 
17086 #line 2682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17087  _p2 = _p1;
17088 #line 17088 OMC_FILE
17089 
17090 #line 2683 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17091  _b = 1;
17092 #line 17092 OMC_FILE
17093 
17094 #line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17095  while(1)
17096 #line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17097  {
17098 #line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17099  if(!_b) break;
17100 #line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17101 
17102 #line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17103 
17104 #line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17105 
17106 #line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17107 
17108 #line 17108 OMC_FILE
17109  { /* match expression */
17110  modelica_metatype tmp8_1;
17111  tmp8_1 = _p2;
17112  {
17113  int tmp8;
17114  {
17115  switch (MMC_SWITCH_CAST(valueConstructor(tmp8_1))) {
17116  case 4: {
17117 
17118  /* Pattern matching succeeded */
17119 #line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17120  tmpMeta[0+0] = _p2;
17121 #line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17122  tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
17123 #line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17124  tmp5_c2 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2))));
17125 #line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17126  tmp5_c3 = 0;
17127 #line 17127 OMC_FILE
17128  goto tmp7_done;
17129  }
17130  case 3: {
17131 
17132  /* Pattern matching succeeded */
17133 #line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17134  tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 3)));
17135 #line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17136  tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
17137 #line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17138  tmp5_c2 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2))));
17139 #line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17140  tmp5_c3 = 1;
17141 #line 17141 OMC_FILE
17142  goto tmp7_done;
17143  }
17144  case 5: {
17145 
17146  /* Pattern matching succeeded */
17147 #line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17148  tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2)));
17149 #line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17150  tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
17151 #line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17152  tmp5_c2 = (modelica_integer)_count;
17153 #line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17154  tmp5_c3 = 1;
17155 #line 17155 OMC_FILE
17156  goto tmp7_done;
17157  }
17158  }
17159  goto tmp7_end;
17160  tmp7_end: ;
17161  }
17162  goto goto_6;
17163  goto_6:;
17164  MMC_THROW_INTERNAL();
17165  goto tmp7_done;
17166  tmp7_done:;
17167  }
17168  }
17169  _p2 = tmpMeta[0+0];
17170  _len = tmp5_c1;
17171  _count = tmp5_c2;
17172  _b = tmp5_c3;
17173  }
17174 
17175 #line 2691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17176  _s = omc_Absyn_pathStringWork(threadData, _p1, (((modelica_integer) -1) + (modelica_integer)_len) * ((modelica_integer)_dlen) + (modelica_integer)_count, _delimiter, (modelica_integer)_dlen, _reverse);
17177 #line 17177 OMC_FILE
17178  _return: OMC_LABEL_UNUSED
17179  return _s;
17180 }
PROTECTED_FUNCTION_STATIC modelica_string omc_Absyn_pathStringWork(threadData_t *threadData, modelica_metatype _inPath, modelica_integer _len, modelica_string _delimiter, modelica_integer _dlen, modelica_boolean _reverse)
Definition: Absyn.c:16897
modelica_metatype modelica_string
m_integer modelica_integer
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_makeNotFullyQualified(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:8283
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathStringDefault()

DLLExport modelica_string omc_Absyn_pathStringDefault ( threadData_t threadData,
modelica_metatype  _path 
)

Definition at line 16714 of file Absyn.c.

16715 {
16716  modelica_string _s = NULL;
16717  MMC_SO();
16718  _tailrecursive: OMC_LABEL_UNUSED
16719  _s = omc_Absyn_pathString(threadData, _path, _OMC_LIT1, 1, 0);
16720  _return: OMC_LABEL_UNUSED
16721  return _s;
16722 }
modelica_metatype modelica_string
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathStringNoQual()

DLLExport modelica_string omc_Absyn_pathStringNoQual ( threadData_t threadData,
modelica_metatype  _path,
modelica_string  _delimiter,
modelica_boolean  _usefq,
modelica_boolean  _reverse 
)

Definition at line 16725 of file Absyn.c.

16726 {
16727  modelica_string _s = NULL;
16728  modelica_metatype _p1 = NULL;
16729  modelica_metatype _p2 = NULL;
16730  modelica_integer _count;
16731  modelica_integer _len;
16732  modelica_integer _dlen;
16733  modelica_boolean _b;
16734  modelica_integer tmp5_c1 __attribute__((unused)) = 0;
16735  modelica_integer tmp5_c2 __attribute__((unused)) = 0;
16736  modelica_boolean tmp5_c3 __attribute__((unused)) = 0;
16737  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
16738  MMC_SO();
16739  _tailrecursive: OMC_LABEL_UNUSED
16740  _count = ((modelica_integer) 0);
16741  _len = ((modelica_integer) 0);
16742  _dlen = stringLength(_delimiter);
16743 #line 2672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16744  _p1 = (_usefq?_path:omc_Absyn_makeNotFullyQualified(threadData, _path));
16745 #line 16745 OMC_FILE
16746 
16747 #line 16747 OMC_FILE
16748  { /* match expression */
16749  modelica_metatype tmp3_1;
16750  tmp3_1 = _p1;
16751  {
16752  volatile mmc_switch_type tmp3;
16753  int tmp4;
16754  tmp3 = 0;
16755  for (; tmp3 < 2; tmp3++) {
16756  switch (MMC_SWITCH_CAST(tmp3)) {
16757  case 0: {
16758  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
16759 
16760  /* Pattern matching succeeded */
16761 #line 2677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16762  _s = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p1), 2)));
16763 #line 16763 OMC_FILE
16764 
16765 #line 2678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16766  goto _return;
16767 #line 16767 OMC_FILE
16768 #line 16768 OMC_FILE
16769  goto tmp2_done;
16770  }
16771  case 1: {
16772 
16773  /* Pattern matching succeeded */
16774 #line 16774 OMC_FILE
16775  goto tmp2_done;
16776  }
16777  }
16778  goto tmp2_end;
16779  tmp2_end: ;
16780  }
16781  goto goto_1;
16782  goto_1:;
16783  MMC_THROW_INTERNAL();
16784  goto tmp2_done;
16785  tmp2_done:;
16786  }
16787  }
16788  ;
16789 
16790 #line 2682 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16791  _p2 = _p1;
16792 #line 16792 OMC_FILE
16793 
16794 #line 2683 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16795  _b = 1;
16796 #line 16796 OMC_FILE
16797 
16798 #line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16799  while(1)
16800 #line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16801  {
16802 #line 2684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16803  if(!_b) break;
16804 #line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16805 
16806 #line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16807 
16808 #line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16809 
16810 #line 2685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16811 
16812 #line 16812 OMC_FILE
16813  { /* match expression */
16814  modelica_metatype tmp8_1;
16815  tmp8_1 = _p2;
16816  {
16817  int tmp8;
16818  {
16819  switch (MMC_SWITCH_CAST(valueConstructor(tmp8_1))) {
16820  case 4: {
16821 
16822  /* Pattern matching succeeded */
16823 #line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16824  tmpMeta[0+0] = _p2;
16825 #line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16826  tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
16827 #line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16828  tmp5_c2 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2))));
16829 #line 2686 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16830  tmp5_c3 = 0;
16831 #line 16831 OMC_FILE
16832  goto tmp7_done;
16833  }
16834  case 3: {
16835 
16836  /* Pattern matching succeeded */
16837 #line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16838  tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 3)));
16839 #line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16840  tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
16841 #line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16842  tmp5_c2 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2))));
16843 #line 2687 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16844  tmp5_c3 = 1;
16845 #line 16845 OMC_FILE
16846  goto tmp7_done;
16847  }
16848  case 5: {
16849 
16850  /* Pattern matching succeeded */
16851 #line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16852  tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p2), 2)));
16853 #line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16854  tmp5_c1 = ((modelica_integer) 1) + (modelica_integer)_len;
16855 #line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16856  tmp5_c2 = (modelica_integer)_count;
16857 #line 2688 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16858  tmp5_c3 = 1;
16859 #line 16859 OMC_FILE
16860  goto tmp7_done;
16861  }
16862  }
16863  goto tmp7_end;
16864  tmp7_end: ;
16865  }
16866  goto goto_6;
16867  goto_6:;
16868  MMC_THROW_INTERNAL();
16869  goto tmp7_done;
16870  tmp7_done:;
16871  }
16872  }
16873  _p2 = tmpMeta[0+0];
16874  _len = tmp5_c1;
16875  _count = tmp5_c2;
16876  _b = tmp5_c3;
16877  }
16878 
16879 #line 2691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16880  _s = omc_Absyn_pathStringWork(threadData, _p1, (((modelica_integer) -1) + (modelica_integer)_len) * ((modelica_integer)_dlen) + (modelica_integer)_count, _delimiter, (modelica_integer)_dlen, _reverse);
16881 #line 16881 OMC_FILE
16882  _return: OMC_LABEL_UNUSED
16883  return _s;
16884 }
PROTECTED_FUNCTION_STATIC modelica_string omc_Absyn_pathStringWork(threadData_t *threadData, modelica_metatype _inPath, modelica_integer _len, modelica_string _delimiter, modelica_integer _dlen, modelica_boolean _reverse)
Definition: Absyn.c:16897
modelica_metatype modelica_string
m_integer modelica_integer
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_makeNotFullyQualified(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:8283
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathStringUnquoteReplaceDot()

DLLExport modelica_string omc_Absyn_pathStringUnquoteReplaceDot ( threadData_t threadData,
modelica_metatype  _inPath,
modelica_string  _repStr 
)

Definition at line 16151 of file Absyn.c.

16152 {
16153  modelica_string _outString = NULL;
16154  modelica_metatype _strlst = NULL;
16155  modelica_string _rep_rep = NULL;
16156  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
16157  MMC_SO();
16158  _tailrecursive: OMC_LABEL_UNUSED
16159 #line 2860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16160  tmpMeta[0] = stringAppend(_repStr,_repStr);
16161 #line 2860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16162  _rep_rep = tmpMeta[0];
16163 #line 16163 OMC_FILE
16164 
16165 #line 2861 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16166  _strlst = omc_Absyn_pathToStringList(threadData, _inPath);
16167 #line 16167 OMC_FILE
16168 
16169 #line 2862 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16170  _strlst = omc_List_map2(threadData, _strlst, boxvar_System_stringReplace, _repStr, _rep_rep);
16171 #line 16171 OMC_FILE
16172 
16173 #line 2863 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16174  _strlst = omc_List_map(threadData, _strlst, boxvar_System_unquoteIdentifier);
16175 #line 16175 OMC_FILE
16176 
16177 #line 2864 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16178  _outString = stringDelimitList(_strlst, _repStr);
16179 #line 16179 OMC_FILE
16180  _return: OMC_LABEL_UNUSED
16181  return _outString;
16182 }
modelica_metatype modelica_string
DLLExport modelica_metatype omc_Absyn_pathToStringList(threadData_t *threadData, modelica_metatype _path)
Definition: Absyn.c:14992
DLLExport modelica_metatype omc_List_map2(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg1, modelica_metatype _inArg2)
Definition: List.c:12478
DLLExport modelica_metatype omc_List_map(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc)
Definition: List.c:13453
modelica_string stringAppend(modelica_string s1, modelica_string s2)
void * modelica_metatype
metamodelica_string stringDelimitList(modelica_metatype lst, metamodelica_string_const delimiter)
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathStringWork()

PROTECTED_FUNCTION_STATIC modelica_string omc_Absyn_pathStringWork ( threadData_t threadData,
modelica_metatype  _inPath,
modelica_integer  _len,
modelica_string  _delimiter,
modelica_integer  _dlen,
modelica_boolean  _reverse 
)

Definition at line 16897 of file Absyn.c.

16898 {
16899  modelica_string _s = NULL;
16900  modelica_metatype _p = NULL;
16901  modelica_boolean _b;
16902  modelica_integer _count;
16903  modelica_complex _sb;
16904  modelica_integer tmp1_c1 __attribute__((unused)) = 0;
16905  modelica_boolean tmp1_c2 __attribute__((unused)) = 0;
16906  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
16907  MMC_SO();
16908  _tailrecursive: OMC_LABEL_UNUSED
16909  _s = _OMC_LIT2;
16910  _p = _inPath;
16911  _b = 1;
16912  _count = ((modelica_integer) 0);
16914 #line 2711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16915  while(1)
16916 #line 2711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16917  {
16918 #line 2711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16919  if(!_b) break;
16920 #line 2712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16921 
16922 #line 2712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16923 
16924 #line 2712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16925 
16926 #line 16926 OMC_FILE
16927  { /* match expression */
16928  modelica_metatype tmp4_1;
16929  tmp4_1 = _p;
16930  {
16931  int tmp4;
16932  {
16933  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
16934  case 4: {
16935 
16936  /* Pattern matching succeeded */
16937 #line 2715 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16938  omc_System_stringAllocatorStringCopy(threadData, _sb, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2))), (_reverse?(modelica_integer)_len + (-(modelica_integer)_count) - stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2)))):(modelica_integer)_count));
16939 #line 16939 OMC_FILE
16940 #line 2716 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16941  tmpMeta[0+0] = _p;
16942 #line 2716 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16943  tmp1_c1 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2))));
16944 #line 2716 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16945  tmp1_c2 = 0;
16946 #line 16946 OMC_FILE
16947  goto tmp3_done;
16948  }
16949  case 3: {
16950 
16951  /* Pattern matching succeeded */
16952 #line 2719 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16953  omc_System_stringAllocatorStringCopy(threadData, _sb, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2))), (_reverse?(modelica_integer)_len + (-(modelica_integer)_dlen) - stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2)))) - (modelica_integer)_count:(modelica_integer)_count));
16954 #line 16954 OMC_FILE
16955 
16956 #line 2720 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16957  omc_System_stringAllocatorStringCopy(threadData, _sb, _delimiter, (_reverse?(modelica_integer)_len + (-(modelica_integer)_count) - (modelica_integer)_dlen:(modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2))))));
16958 #line 16958 OMC_FILE
16959 #line 2721 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16960  tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 3)));
16961 #line 2721 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16962  tmp1_c1 = (modelica_integer)_count + stringLength((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2)))) + (modelica_integer)_dlen;
16963 #line 2721 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16964  tmp1_c2 = 1;
16965 #line 16965 OMC_FILE
16966  goto tmp3_done;
16967  }
16968  case 5: {
16969 
16970  /* Pattern matching succeeded */
16971 #line 2724 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16972  omc_System_stringAllocatorStringCopy(threadData, _sb, _delimiter, (_reverse?(modelica_integer)_len + (-(modelica_integer)_count) - (modelica_integer)_dlen:(modelica_integer)_count));
16973 #line 16973 OMC_FILE
16974 #line 2725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16975  tmpMeta[0+0] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_p), 2)));
16976 #line 2725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16977  tmp1_c1 = (modelica_integer)_count + (modelica_integer)_dlen;
16978 #line 2725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16979  tmp1_c2 = 1;
16980 #line 16980 OMC_FILE
16981  goto tmp3_done;
16982  }
16983  }
16984  goto tmp3_end;
16985  tmp3_end: ;
16986  }
16987  goto goto_2;
16988  goto_2:;
16989  MMC_THROW_INTERNAL();
16990  goto tmp3_done;
16991  tmp3_done:;
16992  }
16993  }
16994  _p = tmpMeta[0+0];
16995  _count = tmp1_c1;
16996  _b = tmp1_c2;
16997  }
16998 
16999 #line 2729 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17000  _s = omc_System_stringAllocatorResult(threadData, _sb, _s);
17001 #line 17001 OMC_FILE
17002  _return: OMC_LABEL_UNUSED
17003  omc_System_StringAllocator_destructor(threadData,_sb);
17004  return _s;
17005 }
modelica_metatype modelica_string
m_integer modelica_integer
signed char modelica_boolean
modelica_complex omc_System_StringAllocator_constructor(threadData_t *threadData, modelica_integer _sz)
Definition: System.c:236
void * modelica_complex
modelica_metatype omc_System_stringAllocatorResult(threadData_t *threadData, modelica_complex _sa, modelica_metatype _dummy)
Definition: System.c:166
void * modelica_metatype
DLLExport void omc_System_StringAllocator_destructor(threadData_t *threadData, modelica_complex _str)
Definition: System.c:278
void omc_System_stringAllocatorStringCopy(threadData_t *threadData, modelica_complex _dest, modelica_string _source, modelica_integer _destOffset)
Definition: System.c:202
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathStripSamePrefix()

DLLExport modelica_metatype omc_Absyn_pathStripSamePrefix ( threadData_t threadData,
modelica_metatype  _inPath1,
modelica_metatype  _inPath2 
)

Definition at line 15364 of file Absyn.c.

15365 {
15366  modelica_metatype _outPath = NULL;
15367  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
15368  MMC_SO();
15369  _tailrecursive: OMC_LABEL_UNUSED
15370 #line 15370 OMC_FILE
15371  { /* matchcontinue expression */
15372  {
15373  modelica_string _ident1 = NULL;
15374  modelica_string _ident2 = NULL;
15375  modelica_metatype _path1 = NULL;
15376  modelica_metatype _path2 = NULL;
15377  volatile mmc_switch_type tmp3;
15378  int tmp4;
15379  tmp3 = 0;
15380  MMC_TRY_INTERNAL(mmc_jumper)
15381  tmp2_top:
15382  threadData->mmc_jumper = &new_mmc_jumper;
15383  for (; tmp3 < 2; tmp3++) {
15384  switch (MMC_SWITCH_CAST(tmp3)) {
15385  case 0: {
15386  modelica_boolean tmp5;
15387  /* Pattern matching succeeded */
15388 #line 3047 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15389  _ident1 = omc_Absyn_pathFirstIdent(threadData, _inPath1);
15390 #line 15390 OMC_FILE
15391 
15392 #line 3048 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15393  _ident2 = omc_Absyn_pathFirstIdent(threadData, _inPath2);
15394 #line 15394 OMC_FILE
15395 
15396 #line 3049 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15397  /* Pattern-matching assignment */
15398 #line 3049 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15399  tmp5 = (stringEqual(_ident1, _ident2));
15400 #line 3049 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15401  if (1 != tmp5) goto goto_1;
15402 #line 15402 OMC_FILE
15403 
15404 #line 3050 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15405  _path1 = omc_Absyn_stripFirst(threadData, _inPath1);
15406 #line 15406 OMC_FILE
15407 
15408 #line 3051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15409  _path2 = omc_Absyn_stripFirst(threadData, _inPath2);
15410 #line 15410 OMC_FILE
15411 #line 3052 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15412  tmpMeta[0] = omc_Absyn_pathStripSamePrefix(threadData, _path1, _path2);
15413 #line 15413 OMC_FILE
15414  goto tmp2_done;
15415  }
15416  case 1: {
15417  /* Pattern matching succeeded */
15418 #line 3055 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15419  tmpMeta[0] = _inPath1;
15420 #line 15420 OMC_FILE
15421  goto tmp2_done;
15422  }
15423  }
15424  goto tmp2_end;
15425  tmp2_end: ;
15426  }
15427  goto goto_1;
15428  tmp2_done:
15429  (void)tmp3;
15430  MMC_RESTORE_INTERNAL(mmc_jumper);
15431  goto tmp2_done2;
15432  goto_1:;
15433  MMC_CATCH_INTERNAL(mmc_jumper);
15434  if (++tmp3 < 2) {
15435  goto tmp2_top;
15436  }
15437  MMC_THROW_INTERNAL();
15438  tmp2_done2:;
15439  }
15440  }
15441  _outPath = tmpMeta[0];
15442  _return: OMC_LABEL_UNUSED
15443  return _outPath;
15444 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
DLLExport modelica_metatype omc_Absyn_stripFirst(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:12159
DLLExport modelica_string omc_Absyn_pathFirstIdent(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:15652
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_pathStripSamePrefix(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:15364
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathSuffixOf()

DLLExport modelica_boolean omc_Absyn_pathSuffixOf ( threadData_t threadData,
modelica_metatype  _suffix_path,
modelica_metatype  _path 
)

Definition at line 15029 of file Absyn.c.

15030 {
15031  modelica_boolean _res;
15032  modelica_boolean tmp1 = 0;
15033  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
15034  MMC_SO();
15035  _tailrecursive: OMC_LABEL_UNUSED
15036 #line 15036 OMC_FILE
15037  { /* matchcontinue expression */
15038  volatile modelica_metatype tmp4_1;
15039  tmp4_1 = _path;
15040  {
15041  modelica_metatype _p = NULL;
15042  volatile mmc_switch_type tmp4;
15043  int tmp5;
15044  tmp4 = 0;
15045  MMC_TRY_INTERNAL(mmc_jumper)
15046  tmp3_top:
15047  threadData->mmc_jumper = &new_mmc_jumper;
15048  for (; tmp4 < 4; tmp4++) {
15049  switch (MMC_SWITCH_CAST(tmp4)) {
15050  case 0: {
15051  modelica_boolean tmp6;
15052 
15053  /* Pattern matching succeeded */
15054 #line 3142 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15055  /* Pattern-matching assignment */
15056 #line 3142 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15057  tmp6 = omc_Absyn_pathEqual(threadData, _suffix_path, _path);
15058 #line 3142 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15059  if (1 != tmp6) goto goto_2;
15060 #line 15060 OMC_FILE
15061 #line 3143 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15062  tmp1 = 1;
15063 #line 15063 OMC_FILE
15064  goto tmp3_done;
15065  }
15066  case 1: {
15067  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
15068  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
15069  _p = tmpMeta[0];
15070  tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
15071 #line 3145 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15072  tmp1 = omc_Absyn_pathSuffixOf(threadData, _suffix_path, _p);
15073 #line 15073 OMC_FILE
15074  goto tmp3_done;
15075  }
15076  case 2: {
15077  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
15078  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
15079  _p = tmpMeta[0];
15080  /* Pattern matching succeeded */
15081 #line 3147 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15082  tmp1 = omc_Absyn_pathSuffixOf(threadData, _suffix_path, _p);
15083 #line 15083 OMC_FILE
15084  goto tmp3_done;
15085  }
15086  case 3: {
15087 
15088  /* Pattern matching succeeded */
15089 #line 3148 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15090  tmp1 = 0;
15091 #line 15091 OMC_FILE
15092  goto tmp3_done;
15093  }
15094  }
15095  goto tmp3_end;
15096  tmp3_end: ;
15097  }
15098  goto goto_2;
15099  tmp3_done:
15100  (void)tmp4;
15101  MMC_RESTORE_INTERNAL(mmc_jumper);
15102  goto tmp3_done2;
15103  goto_2:;
15104  MMC_CATCH_INTERNAL(mmc_jumper);
15105  if (++tmp4 < 4) {
15106  goto tmp3_top;
15107  }
15108  MMC_THROW_INTERNAL();
15109  tmp3_done2:;
15110  }
15111  }
15112  _res = tmp1;
15113  _return: OMC_LABEL_UNUSED
15114  return _res;
15115 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
DLLExport modelica_boolean omc_Absyn_pathEqual(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:17616
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_pathSuffixOf(threadData_t *threadData, modelica_metatype _suffix_path, modelica_metatype _path)
Definition: Absyn.c:15029
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathSuffixOfr()

DLLExport modelica_boolean omc_Absyn_pathSuffixOfr ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _suffix_path 
)

Definition at line 15008 of file Absyn.c.

15009 {
15010  modelica_boolean _res;
15011  MMC_SO();
15012  _tailrecursive: OMC_LABEL_UNUSED
15013 #line 3157 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15014  _res = omc_Absyn_pathSuffixOf(threadData, _suffix_path, _path);
15015 #line 15015 OMC_FILE
15016  _return: OMC_LABEL_UNUSED
15017  return _res;
15018 }
signed char modelica_boolean
DLLExport modelica_boolean omc_Absyn_pathSuffixOf(threadData_t *threadData, modelica_metatype _suffix_path, modelica_metatype _path)
Definition: Absyn.c:15029
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathToCref()

DLLExport modelica_metatype omc_Absyn_pathToCref ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 11873 of file Absyn.c.

11874 {
11875  modelica_metatype _outComponentRef = NULL;
11876  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
11877  MMC_SO();
11878  _tailrecursive: OMC_LABEL_UNUSED
11879 #line 11879 OMC_FILE
11880  { /* match expression */
11881  modelica_metatype tmp3_1;
11882  tmp3_1 = _inPath;
11883  {
11884  modelica_string _i = NULL;
11885  modelica_metatype _c = NULL;
11886  modelica_metatype _p = NULL;
11887  int tmp3;
11888  {
11889  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
11890  case 4: {
11891  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
11892  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11893  _i = tmpMeta[1];
11894  /* Pattern matching succeeded */
11895 #line 4067 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11896  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
11897 #line 4067 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11898  tmpMeta[2] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _i, tmpMeta[1]);
11899 #line 4067 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11900  tmpMeta[0] = tmpMeta[2];
11901 #line 11901 OMC_FILE
11902  goto tmp2_done;
11903  }
11904  case 3: {
11905  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
11906  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11907  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
11908  _i = tmpMeta[1];
11909  _p = tmpMeta[2];
11910  /* Pattern matching succeeded */
11911 #line 4070 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11912  _c = omc_Absyn_pathToCref(threadData, _p);
11913 #line 11913 OMC_FILE
11914 #line 4071 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11915  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
11916 #line 4071 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11917  tmpMeta[2] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _i, tmpMeta[1], _c);
11918 #line 4071 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11919  tmpMeta[0] = tmpMeta[2];
11920 #line 11920 OMC_FILE
11921  goto tmp2_done;
11922  }
11923  case 5: {
11924  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
11925  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11926  _p = tmpMeta[1];
11927  /* Pattern matching succeeded */
11928 #line 4075 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11929  _c = omc_Absyn_pathToCref(threadData, _p);
11930 #line 11930 OMC_FILE
11931 #line 4076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11932  tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _c);
11933 #line 11933 OMC_FILE
11934  goto tmp2_done;
11935  }
11936  }
11937  goto tmp2_end;
11938  tmp2_end: ;
11939  }
11940  goto goto_1;
11941  goto_1:;
11942  MMC_THROW_INTERNAL();
11943  goto tmp2_done;
11944  tmp2_done:;
11945  }
11946  }
11947  _outComponentRef = tmpMeta[0];
11948  _return: OMC_LABEL_UNUSED
11949  return _outComponentRef;
11950 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
modelica_metatype modelica_string
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
DLLExport modelica_metatype omc_Absyn_pathToCref(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:11873
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathToCrefWithSubs()

DLLExport modelica_metatype omc_Absyn_pathToCrefWithSubs ( threadData_t threadData,
modelica_metatype  _inPath,
modelica_metatype  _inSubs 
)

Definition at line 11795 of file Absyn.c.

11796 {
11797  modelica_metatype _outComponentRef = NULL;
11798  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
11799  MMC_SO();
11800  _tailrecursive: OMC_LABEL_UNUSED
11801 #line 11801 OMC_FILE
11802  { /* match expression */
11803  modelica_metatype tmp3_1;
11804  tmp3_1 = _inPath;
11805  {
11806  modelica_string _i = NULL;
11807  modelica_metatype _c = NULL;
11808  modelica_metatype _p = NULL;
11809  int tmp3;
11810  {
11811  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
11812  case 4: {
11813  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
11814  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11815  _i = tmpMeta[1];
11816  /* Pattern matching succeeded */
11817 #line 4093 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11818  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _i, _inSubs);
11819 #line 4093 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11820  tmpMeta[0] = tmpMeta[1];
11821 #line 11821 OMC_FILE
11822  goto tmp2_done;
11823  }
11824  case 3: {
11825  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
11826  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11827  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
11828  _i = tmpMeta[1];
11829  _p = tmpMeta[2];
11830  /* Pattern matching succeeded */
11831 #line 4097 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11832  _c = omc_Absyn_pathToCrefWithSubs(threadData, _p, _inSubs);
11833 #line 11833 OMC_FILE
11834 #line 4098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11835  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
11836 #line 4098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11837  tmpMeta[2] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _i, tmpMeta[1], _c);
11838 #line 4098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11839  tmpMeta[0] = tmpMeta[2];
11840 #line 11840 OMC_FILE
11841  goto tmp2_done;
11842  }
11843  case 5: {
11844  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
11845  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
11846  _p = tmpMeta[1];
11847  /* Pattern matching succeeded */
11848 #line 4103 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11849  _c = omc_Absyn_pathToCrefWithSubs(threadData, _p, _inSubs);
11850 #line 11850 OMC_FILE
11851 #line 4104 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
11852  tmpMeta[0] = omc_Absyn_crefMakeFullyQualified(threadData, _c);
11853 #line 11853 OMC_FILE
11854  goto tmp2_done;
11855  }
11856  }
11857  goto tmp2_end;
11858  tmp2_end: ;
11859  }
11860  goto goto_1;
11861  goto_1:;
11862  MMC_THROW_INTERNAL();
11863  goto tmp2_done;
11864  tmp2_done:;
11865  }
11866  }
11867  _outComponentRef = tmpMeta[0];
11868  _return: OMC_LABEL_UNUSED
11869  return _outComponentRef;
11870 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
modelica_metatype modelica_string
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
DLLExport modelica_metatype omc_Absyn_pathToCrefWithSubs(threadData_t *threadData, modelica_metatype _inPath, modelica_metatype _inSubs)
Definition: Absyn.c:11795
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathToStringList()

DLLExport modelica_metatype omc_Absyn_pathToStringList ( threadData_t threadData,
modelica_metatype  _path 
)

Definition at line 14992 of file Absyn.c.

14993 {
14994  modelica_metatype _outPaths = NULL;
14995  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
14996  MMC_SO();
14997  _tailrecursive: OMC_LABEL_UNUSED
14998 #line 3164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14999  tmpMeta[0] = MMC_REFSTRUCTLIT(mmc_nil);
15000 #line 3164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15001  _outPaths = listReverse(omc_Absyn_pathToStringListWork(threadData, _path, tmpMeta[0]));
15002 #line 15002 OMC_FILE
15003  _return: OMC_LABEL_UNUSED
15004  return _outPaths;
15005 }
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_pathToStringListWork(threadData_t *threadData, modelica_metatype _path, modelica_metatype _acc)
Definition: Absyn.c:14909
void * modelica_metatype
modelica_metatype listReverse(modelica_metatype)
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_pathToStringListWork()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_pathToStringListWork ( threadData_t threadData,
modelica_metatype  _path,
modelica_metatype  _acc 
)

Definition at line 14909 of file Absyn.c.

14910 {
14911  modelica_metatype _outPaths = NULL;
14912  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
14913  MMC_SO();
14914  _tailrecursive: OMC_LABEL_UNUSED
14915 #line 14915 OMC_FILE
14916  { /* match expression */
14917  modelica_metatype tmp3_1;
14918  tmp3_1 = _path;
14919  {
14920  modelica_string _n = NULL;
14921  modelica_metatype _p = NULL;
14922  int tmp3;
14923  {
14924  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
14925  case 4: {
14926  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
14927  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14928  _n = tmpMeta[1];
14929  /* Pattern matching succeeded */
14930 #line 3178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14931  tmpMeta[1] = mmc_mk_cons(_n, _acc);
14932 #line 3178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14933  tmpMeta[0] = tmpMeta[1];
14934 #line 14934 OMC_FILE
14935  goto tmp2_done;
14936  }
14937  case 5: {
14938  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
14939  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14940  _p = tmpMeta[1];
14941  /* Pattern matching succeeded */
14942 #line 3179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14943  /* Tail recursive call */
14944 #line 3179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14945  _path = _p;
14946 #line 3179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14947  goto _tailrecursive;
14948 #line 3179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14949  /* TODO: Make sure any eventual dead code below is never generated */
14950 #line 14950 OMC_FILE
14951  goto tmp2_done;
14952  }
14953  case 3: {
14954  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
14955  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14956  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
14957  _n = tmpMeta[1];
14958  _p = tmpMeta[2];
14959  /* Pattern matching succeeded */
14960 #line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14961  tmpMeta[1] = mmc_mk_cons(_n, _acc);
14962 #line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14963  /* Tail recursive call */
14964 #line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14965  _path = _p;
14966 #line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14967  _acc = tmpMeta[1];
14968 #line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14969  goto _tailrecursive;
14970 #line 3181 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14971  /* TODO: Make sure any eventual dead code below is never generated */
14972 #line 14972 OMC_FILE
14973  goto tmp2_done;
14974  }
14975  }
14976  goto tmp2_end;
14977  tmp2_end: ;
14978  }
14979  goto goto_1;
14980  goto_1:;
14981  MMC_THROW_INTERNAL();
14982  goto tmp2_done;
14983  tmp2_done:;
14984  }
14985  }
14986  _outPaths = tmpMeta[0];
14987  _return: OMC_LABEL_UNUSED
14988  return _outPaths;
14989 }
modelica_metatype modelica_string
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_pathToTypeSpec()

DLLExport modelica_metatype omc_Absyn_pathToTypeSpec ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 4391 of file Absyn.c.

4392 {
4393  modelica_metatype _outTypeSpec = NULL;
4394  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
4395  MMC_SO();
4396  _tailrecursive: OMC_LABEL_UNUSED
4397 #line 5884 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4398  tmpMeta[0] = mmc_mk_box3(3, &Absyn_TypeSpec_TPATH__desc, _inPath, mmc_mk_none());
4399 #line 5884 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4400  _outTypeSpec = tmpMeta[0];
4401 #line 4401 OMC_FILE
4402  _return: OMC_LABEL_UNUSED
4403  return _outTypeSpec;
4404 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_TypeSpec_TPATH__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_pathTwoLastIdents()

DLLExport modelica_metatype omc_Absyn_pathTwoLastIdents ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 15872 of file Absyn.c.

15873 {
15874  modelica_metatype _outTwoLast = NULL;
15875  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
15876  MMC_SO();
15877  _tailrecursive: OMC_LABEL_UNUSED
15878 #line 15878 OMC_FILE
15879  { /* match expression */
15880  modelica_metatype tmp3_1;
15881  tmp3_1 = _inPath;
15882  {
15883  modelica_metatype _p = NULL;
15884  volatile mmc_switch_type tmp3;
15885  int tmp4;
15886  tmp3 = 0;
15887  for (; tmp3 < 3; tmp3++) {
15888  switch (MMC_SWITCH_CAST(tmp3)) {
15889  case 0: {
15890  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
15891  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
15892  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,1) == 0) goto tmp2_end;
15893 
15894  /* Pattern matching succeeded */
15895 #line 2944 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15896  tmpMeta[0] = _inPath;
15897 #line 15897 OMC_FILE
15898  goto tmp2_done;
15899  }
15900  case 1: {
15901  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
15902  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
15903  _p = tmpMeta[1];
15904  /* Pattern matching succeeded */
15905 #line 2945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15906  /* Tail recursive call */
15907 #line 2945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15908  _inPath = _p;
15909 #line 2945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15910  goto _tailrecursive;
15911 #line 2945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15912  /* TODO: Make sure any eventual dead code below is never generated */
15913 #line 15913 OMC_FILE
15914  goto tmp2_done;
15915  }
15916  case 2: {
15917  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
15918  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15919  _p = tmpMeta[1];
15920  /* Pattern matching succeeded */
15921 #line 2946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15922  /* Tail recursive call */
15923 #line 2946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15924  _inPath = _p;
15925 #line 2946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15926  goto _tailrecursive;
15927 #line 2946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15928  /* TODO: Make sure any eventual dead code below is never generated */
15929 #line 15929 OMC_FILE
15930  goto tmp2_done;
15931  }
15932  }
15933  goto tmp2_end;
15934  tmp2_end: ;
15935  }
15936  goto goto_1;
15937  goto_1:;
15938  MMC_THROW_INTERNAL();
15939  goto tmp2_done;
15940  tmp2_done:;
15941  }
15942  }
15943  _outTwoLast = tmpMeta[0];
15944  _return: OMC_LABEL_UNUSED
15945  return _outTwoLast;
15946 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_prefixOptPath()

DLLExport modelica_metatype omc_Absyn_prefixOptPath ( threadData_t threadData,
modelica_string  _prefix,
modelica_metatype  _optPath 
)

Definition at line 15205 of file Absyn.c.

15206 {
15207  modelica_metatype _outPath = NULL;
15208  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
15209  MMC_SO();
15210  _tailrecursive: OMC_LABEL_UNUSED
15211 #line 15211 OMC_FILE
15212  { /* match expression */
15213  modelica_metatype tmp3_1;
15214  tmp3_1 = _optPath;
15215  {
15216  modelica_metatype _path = NULL;
15217  volatile mmc_switch_type tmp3;
15218  int tmp4;
15219  tmp3 = 0;
15220  for (; tmp3 < 2; tmp3++) {
15221  switch (MMC_SWITCH_CAST(tmp3)) {
15222  case 0: {
15223  if (!optionNone(tmp3_1)) goto tmp2_end;
15224  /* Pattern matching succeeded */
15225 #line 3098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15226  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _prefix);
15227 #line 3098 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15228  tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
15229 #line 15229 OMC_FILE
15230  goto tmp2_done;
15231  }
15232  case 1: {
15233  if (optionNone(tmp3_1)) goto tmp2_end;
15234  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
15235  _path = tmpMeta[1];
15236  /* Pattern matching succeeded */
15237 #line 3099 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15238  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _prefix, _path);
15239 #line 3099 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15240  tmpMeta[0] = mmc_mk_some(tmpMeta[1]);
15241 #line 15241 OMC_FILE
15242  goto tmp2_done;
15243  }
15244  }
15245  goto tmp2_end;
15246  tmp2_end: ;
15247  }
15248  goto goto_1;
15249  goto_1:;
15250  MMC_THROW_INTERNAL();
15251  goto tmp2_done;
15252  tmp2_done:;
15253  }
15254  }
15255  _outPath = tmpMeta[0];
15256  _return: OMC_LABEL_UNUSED
15257  return _outPath;
15258 }
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_prefixPath()

DLLExport modelica_metatype omc_Absyn_prefixPath ( threadData_t threadData,
modelica_string  _prefix,
modelica_metatype  _path 
)

Definition at line 15261 of file Absyn.c.

15262 {
15263  modelica_metatype _outPath = NULL;
15264  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
15265  MMC_SO();
15266  _tailrecursive: OMC_LABEL_UNUSED
15267 #line 3085 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15268  tmpMeta[0] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _prefix, _path);
15269 #line 3085 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15270  _outPath = tmpMeta[0];
15271 #line 15271 OMC_FILE
15272  _return: OMC_LABEL_UNUSED
15273  return _outPath;
15274 }
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_printComponentRefStr()

DLLExport modelica_string omc_Absyn_printComponentRefStr ( threadData_t threadData,
modelica_metatype  _cr 
)

Definition at line 17769 of file Absyn.c.

17770 {
17771  modelica_string _ostring = NULL;
17772  modelica_string tmp1 = 0;
17773  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
17774  MMC_SO();
17775  _tailrecursive: OMC_LABEL_UNUSED
17776 #line 17776 OMC_FILE
17777  { /* match expression */
17778  modelica_metatype tmp4_1;
17779  tmp4_1 = _cr;
17780  {
17781  modelica_string _s1 = NULL;
17782  modelica_string _s2 = NULL;
17783  modelica_metatype _child = NULL;
17784  int tmp4;
17785  {
17786  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
17787  case 5: {
17788  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
17789  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17790 
17791  _s1 = tmpMeta[0];
17792  /* Pattern matching succeeded */
17793 #line 2530 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17794  tmp1 = _s1;
17795 #line 17795 OMC_FILE
17796  goto tmp3_done;
17797  }
17798  case 4: {
17799  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
17800  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17801  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
17802  _s1 = tmpMeta[0];
17803  _child = tmpMeta[1];
17804  /* Pattern matching succeeded */
17805 #line 2533 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17806  _s2 = omc_Absyn_printComponentRefStr(threadData, _child);
17807 #line 17807 OMC_FILE
17808 #line 2534 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17809  tmpMeta[0] = stringAppend(_s1,_OMC_LIT1);
17810 #line 2534 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17811  tmpMeta[1] = stringAppend(tmpMeta[0],_s2);
17812 #line 2534 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17813  tmp1 = tmpMeta[1];
17814 #line 17814 OMC_FILE
17815  goto tmp3_done;
17816  }
17817  case 3: {
17818  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
17819  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17820  _child = tmpMeta[0];
17821  /* Pattern matching succeeded */
17822 #line 2538 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17823  _s2 = omc_Absyn_printComponentRefStr(threadData, _child);
17824 #line 17824 OMC_FILE
17825 #line 2539 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17826  tmpMeta[0] = stringAppend(_OMC_LIT1,_s2);
17827 #line 2539 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17828  tmp1 = tmpMeta[0];
17829 #line 17829 OMC_FILE
17830  goto tmp3_done;
17831  }
17832  case 7: {
17833 
17834  /* Pattern matching succeeded */
17835 #line 2541 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17836  tmp1 = _OMC_LIT57;
17837 #line 17837 OMC_FILE
17838  goto tmp3_done;
17839  }
17840  case 6: {
17841 
17842  /* Pattern matching succeeded */
17843 #line 2542 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17844  tmp1 = _OMC_LIT58;
17845 #line 17845 OMC_FILE
17846  goto tmp3_done;
17847  }
17848  }
17849  goto tmp3_end;
17850  tmp3_end: ;
17851  }
17852  goto goto_2;
17853  goto_2:;
17854  MMC_THROW_INTERNAL();
17855  goto tmp3_done;
17856  tmp3_done:;
17857  }
17858  }
17859  _ostring = tmp1;
17860  _return: OMC_LABEL_UNUSED
17861  return _ostring;
17862 }
DLLExport modelica_string omc_Absyn_printComponentRefStr(threadData_t *threadData, modelica_metatype _cr)
Definition: Absyn.c:17769
modelica_metatype modelica_string
modelica_string stringAppend(modelica_string s1, modelica_string s2)
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_printImportString()

DLLExport modelica_string omc_Absyn_printImportString ( threadData_t threadData,
modelica_metatype  _imp 
)

Definition at line 17938 of file Absyn.c.

17939 {
17940  modelica_string _ostring = NULL;
17941  modelica_string tmp1 = 0;
17942  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
17943  MMC_SO();
17944  _tailrecursive: OMC_LABEL_UNUSED
17945 #line 17945 OMC_FILE
17946  { /* match expression */
17947  modelica_metatype tmp4_1;
17948  tmp4_1 = _imp;
17949  {
17950  modelica_metatype _path = NULL;
17951  modelica_string _name = NULL;
17952  int tmp4;
17953  {
17954  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
17955  case 3: {
17956  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
17957  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17958 
17959  _name = tmpMeta[0];
17960  /* Pattern matching succeeded */
17961 #line 2480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17962  tmp1 = _name;
17963 #line 17963 OMC_FILE
17964  goto tmp3_done;
17965  }
17966  case 4: {
17967  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
17968  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17969  _path = tmpMeta[0];
17970  /* Pattern matching succeeded */
17971 #line 2483 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17972  tmp1 = omc_Absyn_pathString(threadData, _path, _OMC_LIT1, 1, 0);
17973 #line 17973 OMC_FILE
17974  goto tmp3_done;
17975  }
17976  case 5: {
17977  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
17978  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17979  _path = tmpMeta[0];
17980  /* Pattern matching succeeded */
17981 #line 2488 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17982  tmp1 = omc_Absyn_pathString(threadData, _path, _OMC_LIT1, 1, 0);
17983 #line 17983 OMC_FILE
17984  goto tmp3_done;
17985  }
17986  }
17987  goto tmp3_end;
17988  tmp3_end: ;
17989  }
17990  goto goto_2;
17991  goto_2:;
17992  MMC_THROW_INTERNAL();
17993  goto tmp3_done;
17994  tmp3_done:;
17995  }
17996  }
17997  _ostring = tmp1;
17998  _return: OMC_LABEL_UNUSED
17999  return _ostring;
18000 }
modelica_metatype modelica_string
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_refString()

DLLExport modelica_string omc_Absyn_refString ( threadData_t threadData,
modelica_metatype  _inRef 
)

Definition at line 4185 of file Absyn.c.

4186 {
4187  modelica_string _outStr = NULL;
4188  modelica_string tmp1 = 0;
4189  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
4190  MMC_SO();
4191  _tailrecursive: OMC_LABEL_UNUSED
4192 #line 4192 OMC_FILE
4193  { /* match expression */
4194  modelica_metatype tmp4_1;
4195  tmp4_1 = _inRef;
4196  {
4197  modelica_metatype _cr = NULL;
4198  modelica_metatype _ts = NULL;
4199  modelica_metatype _im = NULL;
4200  int tmp4;
4201  {
4202  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
4203  case 3: {
4204  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
4205  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4206  _cr = tmpMeta[0];
4207  /* Pattern matching succeeded */
4208 #line 5963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4209  tmp1 = omc_Absyn_crefString(threadData, _cr);
4210 #line 4210 OMC_FILE
4211  goto tmp3_done;
4212  }
4213  case 4: {
4214  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
4215  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4216  _ts = tmpMeta[0];
4217  /* Pattern matching succeeded */
4218 #line 5964 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4219  tmp1 = omc_Absyn_typeSpecString(threadData, _ts);
4220 #line 4220 OMC_FILE
4221  goto tmp3_done;
4222  }
4223  case 5: {
4224  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
4225  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4226  _im = tmpMeta[0];
4227  /* Pattern matching succeeded */
4228 #line 5965 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4229  tmp1 = omc_Absyn_importString(threadData, _im);
4230 #line 4230 OMC_FILE
4231  goto tmp3_done;
4232  }
4233  }
4234  goto tmp3_end;
4235  tmp3_end: ;
4236  }
4237  goto goto_2;
4238  goto_2:;
4239  MMC_THROW_INTERNAL();
4240  goto tmp3_done;
4241  tmp3_done:;
4242  }
4243  }
4244  _outStr = tmp1;
4245  _return: OMC_LABEL_UNUSED
4246  return _outStr;
4247 }
DLLExport modelica_string omc_Absyn_typeSpecString(threadData_t *threadData, modelica_metatype _inTs)
Definition: Absyn.c:4378
modelica_metatype modelica_string
DLLExport modelica_string omc_Absyn_importString(threadData_t *threadData, modelica_metatype _inImp)
Definition: Absyn.c:4250
DLLExport modelica_string omc_Absyn_crefString(threadData_t *threadData, modelica_metatype _inCr)
Definition: Absyn.c:4365
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_refStringBrief()

DLLExport modelica_string omc_Absyn_refStringBrief ( threadData_t threadData,
modelica_metatype  _inRef 
)

Definition at line 4120 of file Absyn.c.

4121 {
4122  modelica_string _outStr = NULL;
4123  modelica_string tmp1 = 0;
4124  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
4125  MMC_SO();
4126  _tailrecursive: OMC_LABEL_UNUSED
4127 #line 4127 OMC_FILE
4128  { /* match expression */
4129  modelica_metatype tmp4_1;
4130  tmp4_1 = _inRef;
4131  {
4132  modelica_metatype _cr = NULL;
4133  modelica_metatype _ts = NULL;
4134  modelica_metatype _im = NULL;
4135  int tmp4;
4136  {
4137  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
4138  case 3: {
4139  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
4140  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4141  _cr = tmpMeta[0];
4142  /* Pattern matching succeeded */
4143 #line 5978 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4144  tmp1 = omc_Absyn_crefStringIgnoreSubs(threadData, _cr);
4145 #line 4145 OMC_FILE
4146  goto tmp3_done;
4147  }
4148  case 4: {
4149  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
4150  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4151  _ts = tmpMeta[0];
4152  /* Pattern matching succeeded */
4153 #line 5979 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4154  tmp1 = omc_Absyn_typeSpecStringNoQualNoDims(threadData, _ts);
4155 #line 4155 OMC_FILE
4156  goto tmp3_done;
4157  }
4158  case 5: {
4159  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
4160  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4161  _im = tmpMeta[0];
4162  /* Pattern matching succeeded */
4163 #line 5980 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4164  tmp1 = omc_Absyn_importString(threadData, _im);
4165 #line 4165 OMC_FILE
4166  goto tmp3_done;
4167  }
4168  }
4169  goto tmp3_end;
4170  tmp3_end: ;
4171  }
4172  goto goto_2;
4173  goto_2:;
4174  MMC_THROW_INTERNAL();
4175  goto tmp3_done;
4176  tmp3_done:;
4177  }
4178  }
4179  _outStr = tmp1;
4180  _return: OMC_LABEL_UNUSED
4181  return _outStr;
4182 }
modelica_metatype modelica_string
DLLExport modelica_string omc_Absyn_crefStringIgnoreSubs(threadData_t *threadData, modelica_metatype _inCr)
Definition: Absyn.c:4263
DLLExport modelica_string omc_Absyn_typeSpecStringNoQualNoDims(threadData_t *threadData, modelica_metatype _inTs)
Definition: Absyn.c:4294
DLLExport modelica_string omc_Absyn_importString(threadData_t *threadData, modelica_metatype _inImp)
Definition: Absyn.c:4250
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_removeCrefFromCrefs()

DLLExport modelica_metatype omc_Absyn_removeCrefFromCrefs ( threadData_t threadData,
modelica_metatype  _inAbsynComponentRefLst,
modelica_metatype  _inComponentRef 
)

Definition at line 3886 of file Absyn.c.

3887 {
3888  modelica_metatype _outAbsynComponentRefLst = NULL;
3889  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
3890  MMC_SO();
3891  _tailrecursive: OMC_LABEL_UNUSED
3892 #line 3892 OMC_FILE
3893  { /* matchcontinue expression */
3894  volatile modelica_metatype tmp3_1;volatile modelica_metatype tmp3_2;
3895  tmp3_1 = _inAbsynComponentRefLst;
3896  tmp3_2 = _inComponentRef;
3897  {
3898  modelica_string _n1 = NULL;
3899  modelica_string _n2 = NULL;
3900  modelica_metatype _rest_1 = NULL;
3901  modelica_metatype _rest = NULL;
3902  modelica_metatype _cr1 = NULL;
3903  modelica_metatype _cr2 = NULL;
3904  volatile mmc_switch_type tmp3;
3905  int tmp4;
3906  tmp3 = 0;
3907  MMC_TRY_INTERNAL(mmc_jumper)
3908  tmp2_top:
3909  threadData->mmc_jumper = &new_mmc_jumper;
3910  for (; tmp3 < 4; tmp3++) {
3911  switch (MMC_SWITCH_CAST(tmp3)) {
3912  case 0: {
3913  if (!listEmpty(tmp3_1)) goto tmp2_end;
3914 
3915  tmp3 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
3916 #line 6006 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3917  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
3918 #line 6006 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3919  tmpMeta[0] = tmpMeta[1];
3920 #line 3920 OMC_FILE
3921  goto tmp2_done;
3922  }
3923  case 1: {
3924  modelica_boolean tmp5;
3925  if (listEmpty(tmp3_1)) goto tmp2_end;
3926  tmpMeta[1] = MMC_CAR(tmp3_1);
3927  tmpMeta[2] = MMC_CDR(tmp3_1);
3928 
3929  _cr1 = tmpMeta[1];
3930  _rest = tmpMeta[2];
3931  _cr2 = tmp3_2;
3932  /* Pattern matching succeeded */
3933 #line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3934  /* Pattern-matching assignment */
3935 #line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3936  tmpMeta[1] = _cr1;
3937 #line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3938  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto goto_1;
3939 #line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3940  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
3941 #line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3942  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
3943 #line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3944  if (!listEmpty(tmpMeta[3])) goto goto_1;
3945 #line 6009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3946  _n1 = tmpMeta[2];
3947 #line 3947 OMC_FILE
3948 
3949 #line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3950  /* Pattern-matching assignment */
3951 #line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3952  tmpMeta[1] = _cr2;
3953 #line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3954  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto goto_1;
3955 #line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3956  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
3957 #line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3958  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 3));
3959 #line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3960  if (!listEmpty(tmpMeta[3])) goto goto_1;
3961 #line 6010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3962  _n2 = tmpMeta[2];
3963 #line 3963 OMC_FILE
3964 
3965 #line 6011 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3966  /* Pattern-matching assignment */
3967 #line 6011 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3968  tmp5 = (stringEqual(_n1, _n2));
3969 #line 6011 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3970  if (1 != tmp5) goto goto_1;
3971 #line 3971 OMC_FILE
3972 #line 6012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3973  tmpMeta[0] = omc_Absyn_removeCrefFromCrefs(threadData, _rest, _cr2);
3974 #line 3974 OMC_FILE
3975  goto tmp2_done;
3976  }
3977  case 2: {
3978  modelica_boolean tmp6;
3979  if (listEmpty(tmp3_1)) goto tmp2_end;
3980  tmpMeta[1] = MMC_CAR(tmp3_1);
3981  tmpMeta[2] = MMC_CDR(tmp3_1);
3982 
3983  _cr1 = tmpMeta[1];
3984  _rest = tmpMeta[2];
3985  _cr2 = tmp3_2;
3986  /* Pattern matching succeeded */
3987 #line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3988  /* Pattern-matching assignment */
3989 #line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3990  tmpMeta[1] = _cr1;
3991 #line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3992  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,3) == 0) goto goto_1;
3993 #line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3994  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
3995 #line 6017 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3996  _n1 = tmpMeta[2];
3997 #line 3997 OMC_FILE
3998 
3999 #line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4000  /* Pattern-matching assignment */
4001 #line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4002  tmpMeta[1] = _cr2;
4003 #line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4004  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,2) == 0) goto goto_1;
4005 #line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4006  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
4007 #line 6018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4008  _n2 = tmpMeta[2];
4009 #line 4009 OMC_FILE
4010 
4011 #line 6019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4012  /* Pattern-matching assignment */
4013 #line 6019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4014  tmp6 = (stringEqual(_n1, _n2));
4015 #line 6019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4016  if (1 != tmp6) goto goto_1;
4017 #line 4017 OMC_FILE
4018 #line 6020 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4019  tmpMeta[0] = omc_Absyn_removeCrefFromCrefs(threadData, _rest, _cr2);
4020 #line 4020 OMC_FILE
4021  goto tmp2_done;
4022  }
4023  case 3: {
4024  if (listEmpty(tmp3_1)) goto tmp2_end;
4025  tmpMeta[1] = MMC_CAR(tmp3_1);
4026  tmpMeta[2] = MMC_CDR(tmp3_1);
4027 
4028  _cr1 = tmpMeta[1];
4029  _rest = tmpMeta[2];
4030  _cr2 = tmp3_2;
4031  /* Pattern matching succeeded */
4032 #line 6025 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4033  _rest_1 = omc_Absyn_removeCrefFromCrefs(threadData, _rest, _cr2);
4034 #line 4034 OMC_FILE
4035 #line 6026 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4036  tmpMeta[1] = mmc_mk_cons(_cr1, _rest_1);
4037 #line 6026 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4038  tmpMeta[0] = tmpMeta[1];
4039 #line 4039 OMC_FILE
4040  goto tmp2_done;
4041  }
4042  }
4043  goto tmp2_end;
4044  tmp2_end: ;
4045  }
4046  goto goto_1;
4047  tmp2_done:
4048  (void)tmp3;
4049  MMC_RESTORE_INTERNAL(mmc_jumper);
4050  goto tmp2_done2;
4051  goto_1:;
4052  MMC_CATCH_INTERNAL(mmc_jumper);
4053  if (++tmp3 < 4) {
4054  goto tmp2_top;
4055  }
4056  MMC_THROW_INTERNAL();
4057  tmp2_done2:;
4058  }
4059  }
4060  _outAbsynComponentRefLst = tmpMeta[0];
4061  _return: OMC_LABEL_UNUSED
4062  return _outAbsynComponentRefLst;
4063 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
signed char modelica_boolean
DLLExport modelica_metatype omc_Absyn_removeCrefFromCrefs(threadData_t *threadData, modelica_metatype _inAbsynComponentRefLst, modelica_metatype _inComponentRef)
Definition: Absyn.c:3886
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_removePartialPrefix()

DLLExport modelica_metatype omc_Absyn_removePartialPrefix ( threadData_t threadData,
modelica_metatype  _inPrefix,
modelica_metatype  _inPath 
)

Definition at line 14276 of file Absyn.c.

14277 {
14278  modelica_metatype _outPath = NULL;
14279  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
14280  MMC_SO();
14281  _tailrecursive: OMC_LABEL_UNUSED
14282 #line 14282 OMC_FILE
14283  { /* matchcontinue expression */
14284  volatile modelica_metatype tmp3_1;
14285  tmp3_1 = _inPrefix;
14286  {
14287  modelica_metatype _p = NULL;
14288  volatile mmc_switch_type tmp3;
14289  int tmp4;
14290  tmp3 = 0;
14291  MMC_TRY_INTERNAL(mmc_jumper)
14292  tmp2_top:
14293  threadData->mmc_jumper = &new_mmc_jumper;
14294  for (; tmp3 < 4; tmp3++) {
14295  switch (MMC_SWITCH_CAST(tmp3)) {
14296  case 0: {
14297 
14298  /* Pattern matching succeeded */
14299 #line 3345 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14300  tmpMeta[0] = omc_Absyn_removePrefix(threadData, _inPrefix, _inPath);
14301 #line 14301 OMC_FILE
14302  goto tmp2_done;
14303  }
14304  case 1: {
14305  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
14306  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
14307  _p = tmpMeta[1];
14308  tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
14309 #line 3351 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14310  tmpMeta[0] = omc_Absyn_removePrefix(threadData, _p, _inPath);
14311 #line 14311 OMC_FILE
14312  goto tmp2_done;
14313  }
14314  case 2: {
14315  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
14316  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14317  _p = tmpMeta[1];
14318  /* Pattern matching succeeded */
14319 #line 3357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14320  tmpMeta[0] = omc_Absyn_removePartialPrefix(threadData, _p, _inPath);
14321 #line 14321 OMC_FILE
14322  goto tmp2_done;
14323  }
14324  case 3: {
14325 
14326  /* Pattern matching succeeded */
14327 #line 3361 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14328  tmpMeta[0] = _inPath;
14329 #line 14329 OMC_FILE
14330  goto tmp2_done;
14331  }
14332  }
14333  goto tmp2_end;
14334  tmp2_end: ;
14335  }
14336  goto goto_1;
14337  tmp2_done:
14338  (void)tmp3;
14339  MMC_RESTORE_INTERNAL(mmc_jumper);
14340  goto tmp2_done2;
14341  goto_1:;
14342  MMC_CATCH_INTERNAL(mmc_jumper);
14343  if (++tmp3 < 4) {
14344  goto tmp2_top;
14345  }
14346  MMC_THROW_INTERNAL();
14347  tmp2_done2:;
14348  }
14349  }
14350  _outPath = tmpMeta[0];
14351  _return: OMC_LABEL_UNUSED
14352  return _outPath;
14353 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_removePrefix(threadData_t *threadData, modelica_metatype _prefix_path, modelica_metatype _path)
Definition: Absyn.c:14356
DLLExport modelica_metatype omc_Absyn_removePartialPrefix(threadData_t *threadData, modelica_metatype _inPrefix, modelica_metatype _inPath)
Definition: Absyn.c:14276
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_removePrefix()

DLLExport modelica_metatype omc_Absyn_removePrefix ( threadData_t threadData,
modelica_metatype  _prefix_path,
modelica_metatype  _path 
)

Definition at line 14356 of file Absyn.c.

14357 {
14358  modelica_metatype _newPath = NULL;
14359  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
14360  MMC_SO();
14361  _tailrecursive: OMC_LABEL_UNUSED
14362 #line 14362 OMC_FILE
14363  { /* match expression */
14364  modelica_metatype tmp3_1;modelica_metatype tmp3_2;
14365  tmp3_1 = _prefix_path;
14366  tmp3_2 = _path;
14367  {
14368  modelica_metatype _p = NULL;
14369  modelica_metatype _p2 = NULL;
14370  modelica_string _id1 = NULL;
14371  modelica_string _id2 = NULL;
14372  volatile mmc_switch_type tmp3;
14373  int tmp4;
14374  tmp3 = 0;
14375  for (; tmp3 < 3; tmp3++) {
14376  switch (MMC_SWITCH_CAST(tmp3)) {
14377  case 0: {
14378  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,2,1) == 0) goto tmp2_end;
14379  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
14380 
14381  _p2 = tmpMeta[1];
14382  _p = tmp3_1;
14383  /* Pattern matching succeeded */
14384 #line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14385  /* Tail recursive call */
14386 #line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14387  _prefix_path = _p;
14388 #line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14389  _path = _p2;
14390 #line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14391  goto _tailrecursive;
14392 #line 3314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14393  /* TODO: Make sure any eventual dead code below is never generated */
14394 #line 14394 OMC_FILE
14395  goto tmp2_done;
14396  }
14397  case 1: {
14398  modelica_boolean tmp5;
14399  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
14400  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14401  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
14402  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,2) == 0) goto tmp2_end;
14403  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
14404  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 3));
14405  _id1 = tmpMeta[1];
14406  _p = tmpMeta[2];
14407  _id2 = tmpMeta[3];
14408  _p2 = tmpMeta[4];
14409  /* Pattern matching succeeded */
14410 #line 3318 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14411  /* Pattern-matching assignment */
14412 #line 3318 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14413  tmp5 = (stringEqual(_id1, _id2));
14414 #line 3318 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14415  if (1 != tmp5) goto goto_1;
14416 #line 14416 OMC_FILE
14417 #line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14418  /* Tail recursive call */
14419 #line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14420  _prefix_path = _p;
14421 #line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14422  _path = _p2;
14423 #line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14424  goto _tailrecursive;
14425 #line 3319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14426  /* TODO: Make sure any eventual dead code below is never generated */
14427 #line 14427 OMC_FILE
14428  goto tmp2_done;
14429  }
14430  case 2: {
14431  modelica_boolean tmp6;
14432  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
14433  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
14434  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,2) == 0) goto tmp2_end;
14435  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 2));
14436  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 3));
14437  _id1 = tmpMeta[1];
14438  _id2 = tmpMeta[2];
14439  _p2 = tmpMeta[3];
14440  /* Pattern matching succeeded */
14441 #line 3324 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14442  /* Pattern-matching assignment */
14443 #line 3324 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14444  tmp6 = (stringEqual(_id1, _id2));
14445 #line 3324 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14446  if (1 != tmp6) goto goto_1;
14447 #line 14447 OMC_FILE
14448 #line 3325 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
14449  tmpMeta[0] = _p2;
14450 #line 14450 OMC_FILE
14451  goto tmp2_done;
14452  }
14453  }
14454  goto tmp2_end;
14455  tmp2_end: ;
14456  }
14457  goto goto_1;
14458  goto_1:;
14459  MMC_THROW_INTERNAL();
14460  goto tmp2_done;
14461  tmp2_done:;
14462  }
14463  }
14464  _newPath = tmpMeta[0];
14465  _return: OMC_LABEL_UNUSED
14466  return _newPath;
14467 }
modelica_metatype modelica_string
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_restrString()

DLLExport modelica_string omc_Absyn_restrString ( threadData_t threadData,
modelica_metatype  _inRestriction 
)

Definition at line 10341 of file Absyn.c.

10342 {
10343  modelica_string _outString = NULL;
10344  modelica_string tmp1 = 0;
10345  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
10346  MMC_SO();
10347  _tailrecursive: OMC_LABEL_UNUSED
10348 #line 10348 OMC_FILE
10349  { /* match expression */
10350  modelica_metatype tmp4_1;
10351  tmp4_1 = _inRestriction;
10352  {
10353  volatile mmc_switch_type tmp4;
10354  int tmp5;
10355  tmp4 = 0;
10356  for (; tmp4 < 20; tmp4++) {
10357  switch (MMC_SWITCH_CAST(tmp4)) {
10358  case 0: {
10359  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
10360  /* Pattern matching succeeded */
10361 #line 4408 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10362  tmp1 = _OMC_LIT32;
10363 #line 10363 OMC_FILE
10364  goto tmp3_done;
10365  }
10366  case 1: {
10367  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
10368  /* Pattern matching succeeded */
10369 #line 4409 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10370  tmp1 = _OMC_LIT33;
10371 #line 10371 OMC_FILE
10372  goto tmp3_done;
10373  }
10374  case 2: {
10375  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,0) == 0) goto tmp3_end;
10376  /* Pattern matching succeeded */
10377 #line 4410 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10378  tmp1 = _OMC_LIT34;
10379 #line 10379 OMC_FILE
10380  goto tmp3_done;
10381  }
10382  case 3: {
10383  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
10384  /* Pattern matching succeeded */
10385 #line 4411 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10386  tmp1 = _OMC_LIT35;
10387 #line 10387 OMC_FILE
10388  goto tmp3_done;
10389  }
10390  case 4: {
10391  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,0) == 0) goto tmp3_end;
10392  /* Pattern matching succeeded */
10393 #line 4412 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10394  tmp1 = _OMC_LIT36;
10395 #line 10395 OMC_FILE
10396  goto tmp3_done;
10397  }
10398  case 5: {
10399  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,0) == 0) goto tmp3_end;
10400  /* Pattern matching succeeded */
10401 #line 4413 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10402  tmp1 = _OMC_LIT37;
10403 #line 10403 OMC_FILE
10404  goto tmp3_done;
10405  }
10406  case 6: {
10407  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,0) == 0) goto tmp3_end;
10408  /* Pattern matching succeeded */
10409 #line 4414 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10410  tmp1 = _OMC_LIT38;
10411 #line 10411 OMC_FILE
10412  goto tmp3_done;
10413  }
10414  case 7: {
10415  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,0) == 0) goto tmp3_end;
10416  /* Pattern matching succeeded */
10417 #line 4415 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10418  tmp1 = _OMC_LIT39;
10419 #line 10419 OMC_FILE
10420  goto tmp3_done;
10421  }
10422  case 8: {
10423  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,0) == 0) goto tmp3_end;
10424  /* Pattern matching succeeded */
10425 #line 4416 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10426  tmp1 = _OMC_LIT40;
10427 #line 10427 OMC_FILE
10428  goto tmp3_done;
10429  }
10430  case 9: {
10431  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
10432  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
10433  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
10434  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
10435  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],0,0) == 0) goto tmp3_end;
10436  /* Pattern matching succeeded */
10437 #line 4417 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10438  tmp1 = _OMC_LIT41;
10439 #line 10439 OMC_FILE
10440  goto tmp3_done;
10441  }
10442  case 10: {
10443  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
10444  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
10445  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
10446  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
10447  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],1,0) == 0) goto tmp3_end;
10448  /* Pattern matching succeeded */
10449 #line 4418 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10450  tmp1 = _OMC_LIT42;
10451 #line 10451 OMC_FILE
10452  goto tmp3_done;
10453  }
10454  case 11: {
10455  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
10456  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
10457  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],0,1) == 0) goto tmp3_end;
10458  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
10459  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[1],2,0) == 0) goto tmp3_end;
10460  /* Pattern matching succeeded */
10461 #line 4419 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10462  tmp1 = _OMC_LIT43;
10463 #line 10463 OMC_FILE
10464  goto tmp3_done;
10465  }
10466  case 12: {
10467  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
10468  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
10469  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[0],1,0) == 0) goto tmp3_end;
10470  /* Pattern matching succeeded */
10471 #line 4420 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10472  tmp1 = _OMC_LIT44;
10473 #line 10473 OMC_FILE
10474  goto tmp3_done;
10475  }
10476  case 13: {
10477  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,13,0) == 0) goto tmp3_end;
10478  /* Pattern matching succeeded */
10479 #line 4421 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10480  tmp1 = _OMC_LIT45;
10481 #line 10481 OMC_FILE
10482  goto tmp3_done;
10483  }
10484  case 14: {
10485  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,14,0) == 0) goto tmp3_end;
10486  /* Pattern matching succeeded */
10487 #line 4422 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10488  tmp1 = _OMC_LIT46;
10489 #line 10489 OMC_FILE
10490  goto tmp3_done;
10491  }
10492  case 15: {
10493  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,15,0) == 0) goto tmp3_end;
10494  /* Pattern matching succeeded */
10495 #line 4423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10496  tmp1 = _OMC_LIT47;
10497 #line 10497 OMC_FILE
10498  goto tmp3_done;
10499  }
10500  case 16: {
10501  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,16,0) == 0) goto tmp3_end;
10502  /* Pattern matching succeeded */
10503 #line 4424 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10504  tmp1 = _OMC_LIT48;
10505 #line 10505 OMC_FILE
10506  goto tmp3_done;
10507  }
10508  case 17: {
10509  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,18,0) == 0) goto tmp3_end;
10510  /* Pattern matching succeeded */
10511 #line 4426 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10512  tmp1 = _OMC_LIT49;
10513 #line 10513 OMC_FILE
10514  goto tmp3_done;
10515  }
10516  case 18: {
10517  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,19,0) == 0) goto tmp3_end;
10518  /* Pattern matching succeeded */
10519 #line 4429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10520  tmp1 = _OMC_LIT50;
10521 #line 10521 OMC_FILE
10522  goto tmp3_done;
10523  }
10524  case 19: {
10525 
10526  /* Pattern matching succeeded */
10527 #line 4430 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10528  tmp1 = _OMC_LIT51;
10529 #line 10529 OMC_FILE
10530  goto tmp3_done;
10531  }
10532  }
10533  goto tmp3_end;
10534  tmp3_end: ;
10535  }
10536  goto goto_2;
10537  goto_2:;
10538  MMC_THROW_INTERNAL();
10539  goto tmp3_done;
10540  tmp3_done:;
10541  }
10542  }
10543  _outString = tmp1;
10544  _return: OMC_LABEL_UNUSED
10545  return _outString;
10546 }
modelica_metatype modelica_string
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_selectPathsOpt()

DLLExport modelica_metatype omc_Absyn_selectPathsOpt ( threadData_t threadData,
modelica_metatype  _inPath1,
modelica_metatype  _inPath2 
)

Definition at line 12621 of file Absyn.c.

12622 {
12623  modelica_metatype _outPath = NULL;
12624  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
12625  MMC_SO();
12626  _tailrecursive: OMC_LABEL_UNUSED
12627 #line 12627 OMC_FILE
12628  { /* match expression */
12629  modelica_metatype tmp3_1;modelica_metatype tmp3_2;
12630  tmp3_1 = _inPath1;
12631  tmp3_2 = _inPath2;
12632  {
12633  modelica_metatype _p = NULL;
12634  volatile mmc_switch_type tmp3;
12635  int tmp4;
12636  tmp3 = 0;
12637  for (; tmp3 < 2; tmp3++) {
12638  switch (MMC_SWITCH_CAST(tmp3)) {
12639  case 0: {
12640  if (!optionNone(tmp3_1)) goto tmp2_end;
12641 
12642  _p = tmp3_2;
12643  /* Pattern matching succeeded */
12644 #line 3851 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12645  tmpMeta[0] = _p;
12646 #line 12646 OMC_FILE
12647  goto tmp2_done;
12648  }
12649  case 1: {
12650  if (optionNone(tmp3_1)) goto tmp2_end;
12651  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 1));
12652 
12653  _p = tmpMeta[1];
12654  /* Pattern matching succeeded */
12655 #line 3852 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12656  tmpMeta[0] = _p;
12657 #line 12657 OMC_FILE
12658  goto tmp2_done;
12659  }
12660  }
12661  goto tmp2_end;
12662  tmp2_end: ;
12663  }
12664  goto goto_1;
12665  goto_1:;
12666  MMC_THROW_INTERNAL();
12667  goto tmp2_done;
12668  tmp2_done:;
12669  }
12670  }
12671  _outPath = tmpMeta[0];
12672  _return: OMC_LABEL_UNUSED
12673  return _outPath;
12674 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_setClassBody()

DLLExport modelica_metatype omc_Absyn_setClassBody ( threadData_t threadData,
modelica_metatype  _inClass,
modelica_metatype  _inBody 
)

Definition at line 10114 of file Absyn.c.

10115 {
10116  modelica_metatype _outClass = NULL;
10117  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
10118  MMC_SO();
10119  _tailrecursive: OMC_LABEL_UNUSED
10120  _outClass = _inClass;
10121 #line 10121 OMC_FILE
10122  { /* match expression */
10123  modelica_metatype tmp3_1;
10124  tmp3_1 = _outClass;
10125  {
10126  volatile mmc_switch_type tmp3;
10127  int tmp4;
10128  tmp3 = 0;
10129  for (; tmp3 < 1; tmp3++) {
10130  switch (MMC_SWITCH_CAST(tmp3)) {
10131  case 0: {
10132 
10133  /* Pattern matching succeeded */
10134 #line 4494 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10135  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
10136 #line 4494 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10137  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outClass), 9*sizeof(modelica_metatype));
10138 #line 4494 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10139  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[7] = _inBody;
10140 #line 4494 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10141  _outClass = tmpMeta[1];
10142 #line 10142 OMC_FILE
10143 #line 4495 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10144  tmpMeta[0] = _outClass;
10145 #line 10145 OMC_FILE
10146  goto tmp2_done;
10147  }
10148  }
10149  goto tmp2_end;
10150  tmp2_end: ;
10151  }
10152  goto goto_1;
10153  goto_1:;
10154  MMC_THROW_INTERNAL();
10155  goto tmp2_done;
10156  tmp2_done:;
10157  }
10158  }
10159  _outClass = tmpMeta[0];
10160  _return: OMC_LABEL_UNUSED
10161  return _outClass;
10162 }
float mmc_switch_type
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_setClassFilename()

DLLExport modelica_metatype omc_Absyn_setClassFilename ( threadData_t threadData,
modelica_metatype  _inClass,
modelica_string  _fileName 
)

Definition at line 10216 of file Absyn.c.

10217 {
10218  modelica_metatype _outClass = NULL;
10219  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
10220  MMC_SO();
10221  _tailrecursive: OMC_LABEL_UNUSED
10222 #line 10222 OMC_FILE
10223  { /* match expression */
10224  modelica_metatype tmp3_1;
10225  tmp3_1 = _inClass;
10226  {
10227  modelica_metatype _info = NULL;
10228  modelica_metatype _cl = NULL;
10229  volatile mmc_switch_type tmp3;
10230  int tmp4;
10231  tmp3 = 0;
10232  for (; tmp3 < 1; tmp3++) {
10233  switch (MMC_SWITCH_CAST(tmp3)) {
10234  case 0: {
10235  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 8));
10236 
10237  _cl = tmp3_1;
10238  _info = tmpMeta[1];
10239  /* Pattern matching succeeded */
10240 #line 4465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10241  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
10242 #line 4465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10243  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_info), 9*sizeof(modelica_metatype));
10244 #line 4465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10245  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = _fileName;
10246 #line 4465 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10247  _info = tmpMeta[1];
10248 #line 10248 OMC_FILE
10249 
10250 #line 4466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10251  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
10252 #line 4466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10253  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_cl), 9*sizeof(modelica_metatype));
10254 #line 4466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10255  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[8] = _info;
10256 #line 4466 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10257  _cl = tmpMeta[1];
10258 #line 10258 OMC_FILE
10259 #line 4467 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10260  tmpMeta[0] = _cl;
10261 #line 10261 OMC_FILE
10262  goto tmp2_done;
10263  }
10264  }
10265  goto tmp2_end;
10266  tmp2_end: ;
10267  }
10268  goto goto_1;
10269  goto_1:;
10270  MMC_THROW_INTERNAL();
10271  goto tmp2_done;
10272  tmp2_done:;
10273  }
10274  }
10275  _outClass = tmpMeta[0];
10276  _return: OMC_LABEL_UNUSED
10277  return _outClass;
10278 }
float mmc_switch_type
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_setClassName()

DLLExport modelica_metatype omc_Absyn_setClassName ( threadData_t threadData,
modelica_metatype  _inClass,
modelica_string  _newName 
)

Definition at line 10165 of file Absyn.c.

10166 {
10167  modelica_metatype _outClass = NULL;
10168  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
10169  MMC_SO();
10170  _tailrecursive: OMC_LABEL_UNUSED
10171  _outClass = _inClass;
10172 #line 10172 OMC_FILE
10173  { /* match expression */
10174  modelica_metatype tmp3_1;
10175  tmp3_1 = _outClass;
10176  {
10177  volatile mmc_switch_type tmp3;
10178  int tmp4;
10179  tmp3 = 0;
10180  for (; tmp3 < 1; tmp3++) {
10181  switch (MMC_SWITCH_CAST(tmp3)) {
10182  case 0: {
10183 
10184  /* Pattern matching succeeded */
10185 #line 4480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10186  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
10187 #line 4480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10188  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outClass), 9*sizeof(modelica_metatype));
10189 #line 4480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10190  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = _newName;
10191 #line 4480 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10192  _outClass = tmpMeta[1];
10193 #line 10193 OMC_FILE
10194 #line 4481 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
10195  tmpMeta[0] = _outClass;
10196 #line 10196 OMC_FILE
10197  goto tmp2_done;
10198  }
10199  }
10200  goto tmp2_end;
10201  tmp2_end: ;
10202  }
10203  goto goto_1;
10204  goto_1:;
10205  MMC_THROW_INTERNAL();
10206  goto tmp2_done;
10207  tmp2_done:;
10208  }
10209  }
10210  _outClass = tmpMeta[0];
10211  _return: OMC_LABEL_UNUSED
10212  return _outClass;
10213 }
float mmc_switch_type
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_splitQualAndIdentPath()

DLLExport modelica_metatype omc_Absyn_splitQualAndIdentPath ( threadData_t threadData,
modelica_metatype  _inPath,
modelica_metatype out_outPath2 
)

Definition at line 12219 of file Absyn.c.

12220 {
12221  modelica_metatype _outPath1 = NULL;
12222  modelica_metatype _outPath2 = NULL;
12223  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
12224  MMC_SO();
12225  _tailrecursive: OMC_LABEL_UNUSED
12226 #line 3957 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12227 
12228 #line 3957 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12229 
12230 #line 12230 OMC_FILE
12231  { /* match expression */
12232  modelica_metatype tmp4_1;
12233  tmp4_1 = _inPath;
12234  {
12235  modelica_metatype _qPath = NULL;
12236  modelica_metatype _curPath = NULL;
12237  modelica_metatype _identPath = NULL;
12238  modelica_string _s1 = NULL;
12239  modelica_string _s2 = NULL;
12240  volatile mmc_switch_type tmp4;
12241  int tmp5;
12242  tmp4 = 0;
12243  for (; tmp4 < 3; tmp4++) {
12244  switch (MMC_SWITCH_CAST(tmp4)) {
12245  case 0: {
12246  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
12247  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
12248  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
12249  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[3],1,1) == 0) goto tmp3_end;
12250  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
12251  _s1 = tmpMeta[2];
12252  _s2 = tmpMeta[4];
12253  /* Pattern matching succeeded */
12254 #line 3963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12255  tmpMeta[2] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s1);
12256 #line 3963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12257  tmpMeta[3] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _s2);
12258 #line 3963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12259  tmpMeta[0+0] = tmpMeta[2];
12260 #line 3963 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12261  tmpMeta[0+1] = tmpMeta[3];
12262 #line 12262 OMC_FILE
12263  goto tmp3_done;
12264  }
12265  case 1: {
12266  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
12267  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
12268  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
12269  _s1 = tmpMeta[2];
12270  _qPath = tmpMeta[3];
12271  /* Pattern matching succeeded */
12272 #line 3967 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12273  _curPath = omc_Absyn_splitQualAndIdentPath(threadData, _qPath ,&_identPath);
12274 #line 12274 OMC_FILE
12275 #line 3968 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12276  tmpMeta[2] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _s1, _curPath);
12277 #line 3968 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12278  tmpMeta[0+0] = tmpMeta[2];
12279 #line 3968 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12280  tmpMeta[0+1] = _identPath;
12281 #line 12281 OMC_FILE
12282  goto tmp3_done;
12283  }
12284  case 2: {
12285  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
12286  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
12287  _qPath = tmpMeta[2];
12288  /* Pattern matching succeeded */
12289 #line 3973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12290  /* Tail recursive call */
12291 #line 3973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12292  _inPath = _qPath;
12293 #line 3973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12294  goto _tailrecursive;
12295 #line 3973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12296  /* TODO: Make sure any eventual dead code below is never generated */
12297 #line 12297 OMC_FILE
12298  goto tmp3_done;
12299  }
12300  }
12301  goto tmp3_end;
12302  tmp3_end: ;
12303  }
12304  goto goto_2;
12305  goto_2:;
12306  MMC_THROW_INTERNAL();
12307  goto tmp3_done;
12308  tmp3_done:;
12309  }
12310  }
12311  _outPath1 = tmpMeta[0+0];
12312  _outPath2 = tmpMeta[0+1];
12313  _return: OMC_LABEL_UNUSED
12314  if (out_outPath2) { *out_outPath2 = _outPath2; }
12315  return _outPath1;
12316 }
modelica_metatype modelica_string
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_splitQualAndIdentPath(threadData_t *threadData, modelica_metatype _inPath, modelica_metatype *out_outPath2)
Definition: Absyn.c:12219
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_stringListPath()

DLLExport modelica_metatype omc_Absyn_stringListPath ( threadData_t threadData,
modelica_metatype  _paths 
)

Definition at line 16056 of file Absyn.c.

16057 {
16058  modelica_metatype _qualifiedPath = NULL;
16059  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
16060  MMC_SO();
16061  _tailrecursive: OMC_LABEL_UNUSED
16062 #line 16062 OMC_FILE
16063  { /* matchcontinue expression */
16064  volatile modelica_metatype tmp3_1;
16065  tmp3_1 = _paths;
16066  {
16067  modelica_string _str = NULL;
16068  modelica_metatype _rest_str = NULL;
16069  modelica_metatype _p = NULL;
16070  volatile mmc_switch_type tmp3;
16071  int tmp4;
16072  tmp3 = 0;
16073  MMC_TRY_INTERNAL(mmc_jumper)
16074  tmp2_top:
16075  threadData->mmc_jumper = &new_mmc_jumper;
16076  for (; tmp3 < 2; tmp3++) {
16077  switch (MMC_SWITCH_CAST(tmp3)) {
16078  case 0: {
16079  if (listEmpty(tmp3_1)) goto tmp2_end;
16080  tmpMeta[1] = MMC_CAR(tmp3_1);
16081  tmpMeta[2] = MMC_CDR(tmp3_1);
16082  if (!listEmpty(tmpMeta[2])) goto tmp2_end;
16083  _str = tmpMeta[1];
16084  /* Pattern matching succeeded */
16085 #line 2890 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16086  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _str);
16087 #line 2890 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16088  tmpMeta[0] = tmpMeta[1];
16089 #line 16089 OMC_FILE
16090  goto tmp2_done;
16091  }
16092  case 1: {
16093  if (listEmpty(tmp3_1)) goto tmp2_end;
16094  tmpMeta[1] = MMC_CAR(tmp3_1);
16095  tmpMeta[2] = MMC_CDR(tmp3_1);
16096  _str = tmpMeta[1];
16097  _rest_str = tmpMeta[2];
16098  /* Pattern matching succeeded */
16099 #line 2893 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16100  _p = omc_Absyn_stringListPath(threadData, _rest_str);
16101 #line 16101 OMC_FILE
16102 #line 2894 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16103  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _str, _p);
16104 #line 2894 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16105  tmpMeta[0] = tmpMeta[1];
16106 #line 16106 OMC_FILE
16107  goto tmp2_done;
16108  }
16109  }
16110  goto tmp2_end;
16111  tmp2_end: ;
16112  }
16113  goto goto_1;
16114  tmp2_done:
16115  (void)tmp3;
16116  MMC_RESTORE_INTERNAL(mmc_jumper);
16117  goto tmp2_done2;
16118  goto_1:;
16119  MMC_CATCH_INTERNAL(mmc_jumper);
16120  if (++tmp3 < 2) {
16121  goto tmp2_top;
16122  }
16123  MMC_THROW_INTERNAL();
16124  tmp2_done2:;
16125  }
16126  }
16127  _qualifiedPath = tmpMeta[0];
16128  _return: OMC_LABEL_UNUSED
16129  return _qualifiedPath;
16130 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
modelica_metatype modelica_string
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
DLLExport modelica_metatype omc_Absyn_stringListPath(threadData_t *threadData, modelica_metatype _paths)
Definition: Absyn.c:16056
Here is the caller graph for this function:

◆ omc_Absyn_stringListPathReversed()

DLLExport modelica_metatype omc_Absyn_stringListPathReversed ( threadData_t threadData,
modelica_metatype  _inStrings 
)

Definition at line 16017 of file Absyn.c.

16018 {
16019  modelica_metatype _outPath = NULL;
16020  modelica_string _id = NULL;
16021  modelica_metatype _rest_str = NULL;
16022  modelica_metatype _path = NULL;
16023  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
16024  MMC_SO();
16025  _tailrecursive: OMC_LABEL_UNUSED
16026 #line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16027  /* Pattern-matching assignment */
16028 #line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16029  tmpMeta[0] = _inStrings;
16030 #line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16031  if (listEmpty(tmpMeta[0])) MMC_THROW_INTERNAL();
16032 #line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16033  tmpMeta[1] = MMC_CAR(tmpMeta[0]);
16034 #line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16035  tmpMeta[2] = MMC_CDR(tmpMeta[0]);
16036 #line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16037  _id = tmpMeta[1];
16038 #line 2909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16039  _rest_str = tmpMeta[2];
16040 #line 16040 OMC_FILE
16041 
16042 #line 2910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16043  tmpMeta[0] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _id);
16044 #line 2910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16045  _path = tmpMeta[0];
16046 #line 16046 OMC_FILE
16047 
16048 #line 2911 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16049  _outPath = omc_Absyn_stringListPathReversed2(threadData, _rest_str, _path);
16050 #line 16050 OMC_FILE
16051  _return: OMC_LABEL_UNUSED
16052  return _outPath;
16053 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_stringListPathReversed2(threadData_t *threadData, modelica_metatype _inStrings, modelica_metatype _inAccumPath)
Definition: Absyn.c:15948
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_stringListPathReversed2()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_stringListPathReversed2 ( threadData_t threadData,
modelica_metatype  _inStrings,
modelica_metatype  _inAccumPath 
)

Definition at line 15948 of file Absyn.c.

15949 {
15950  modelica_metatype _outPath = NULL;
15951  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
15952  MMC_SO();
15953  _tailrecursive: OMC_LABEL_UNUSED
15954 #line 15954 OMC_FILE
15955  { /* match expression */
15956  modelica_metatype tmp3_1;
15957  tmp3_1 = _inStrings;
15958  {
15959  modelica_string _id = NULL;
15960  modelica_metatype _rest_str = NULL;
15961  modelica_metatype _path = NULL;
15962  volatile mmc_switch_type tmp3;
15963  int tmp4;
15964  tmp3 = 0;
15965  for (; tmp3 < 2; tmp3++) {
15966  switch (MMC_SWITCH_CAST(tmp3)) {
15967  case 0: {
15968  if (!listEmpty(tmp3_1)) goto tmp2_end;
15969  /* Pattern matching succeeded */
15970 #line 2925 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15971  tmpMeta[0] = _inAccumPath;
15972 #line 15972 OMC_FILE
15973  goto tmp2_done;
15974  }
15975  case 1: {
15976  if (listEmpty(tmp3_1)) goto tmp2_end;
15977  tmpMeta[1] = MMC_CAR(tmp3_1);
15978  tmpMeta[2] = MMC_CDR(tmp3_1);
15979  _id = tmpMeta[1];
15980  _rest_str = tmpMeta[2];
15981  /* Pattern matching succeeded */
15982 #line 2929 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15983  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _id, _inAccumPath);
15984 #line 2929 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15985  _path = tmpMeta[1];
15986 #line 15986 OMC_FILE
15987 #line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15988  /* Tail recursive call */
15989 #line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15990  _inStrings = _rest_str;
15991 #line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15992  _inAccumPath = _path;
15993 #line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15994  goto _tailrecursive;
15995 #line 2930 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15996  /* TODO: Make sure any eventual dead code below is never generated */
15997 #line 15997 OMC_FILE
15998  goto tmp2_done;
15999  }
16000  }
16001  goto tmp2_end;
16002  tmp2_end: ;
16003  }
16004  goto goto_1;
16005  goto_1:;
16006  MMC_THROW_INTERNAL();
16007  goto tmp2_done;
16008  tmp2_done:;
16009  }
16010  }
16011  _outPath = tmpMeta[0];
16012  _return: OMC_LABEL_UNUSED
16013  return _outPath;
16014 }
modelica_metatype modelica_string
float mmc_switch_type
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_stringPath()

DLLExport modelica_metatype omc_Absyn_stringPath ( threadData_t threadData,
modelica_string  _str 
)

Definition at line 16133 of file Absyn.c.

16134 {
16135  modelica_metatype _qualifiedPath = NULL;
16136  modelica_metatype _paths = NULL;
16137  MMC_SO();
16138  _tailrecursive: OMC_LABEL_UNUSED
16139 #line 2875 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16140  _paths = omc_Util_stringSplitAtChar(threadData, _str, _OMC_LIT1);
16141 #line 16141 OMC_FILE
16142 
16143 #line 2876 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
16144  _qualifiedPath = omc_Absyn_stringListPath(threadData, _paths);
16145 #line 16145 OMC_FILE
16146  _return: OMC_LABEL_UNUSED
16147  return _qualifiedPath;
16148 }
void * modelica_metatype
DLLExport modelica_metatype omc_Util_stringSplitAtChar(threadData_t *threadData, modelica_string _string, modelica_string _token)
Definition: Util.c:4463
DLLExport modelica_metatype omc_Absyn_stringListPath(threadData_t *threadData, modelica_metatype _paths)
Definition: Absyn.c:16056
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_stripClassDefComment()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_stripClassDefComment ( threadData_t threadData,
modelica_metatype  _cl 
)

Definition at line 5777 of file Absyn.c.

5778 {
5779  modelica_metatype _o = NULL;
5780  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
5781  MMC_SO();
5782  _tailrecursive: OMC_LABEL_UNUSED
5783 #line 5783 OMC_FILE
5784  { /* match expression */
5785  modelica_metatype tmp3_1;
5786  tmp3_1 = _cl;
5787  {
5788  modelica_metatype _enumLiterals = NULL;
5789  modelica_metatype _typeSpec = NULL;
5790  modelica_metatype _attributes = NULL;
5791  modelica_metatype _arguments = NULL;
5792  modelica_metatype _functionNames = NULL;
5793  modelica_metatype _functionName = NULL;
5794  modelica_metatype _vars = NULL;
5795  modelica_metatype _typeVars = NULL;
5796  modelica_string _baseClassName = NULL;
5797  modelica_metatype _modifications = NULL;
5798  modelica_metatype _parts = NULL;
5799  modelica_metatype _classAttrs = NULL;
5800  modelica_metatype _ann = NULL;
5801  int tmp3;
5802  {
5803  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
5804  case 3: {
5805  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,5) == 0) goto tmp2_end;
5806  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5807  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
5808  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
5809  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
5810 
5811  _typeVars = tmpMeta[1];
5812  _classAttrs = tmpMeta[2];
5813  _parts = tmpMeta[3];
5814  _ann = tmpMeta[4];
5815  /* Pattern matching succeeded */
5816 #line 5528 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5817  tmpMeta[1] = mmc_mk_box6(3, &Absyn_ClassDef_PARTS__desc, _typeVars, _classAttrs, _parts, _ann, mmc_mk_none());
5818 #line 5528 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5819  tmpMeta[0] = tmpMeta[1];
5820 #line 5820 OMC_FILE
5821  goto tmp2_done;
5822  }
5823  case 7: {
5824  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,4,5) == 0) goto tmp2_end;
5825  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5826  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
5827  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
5828  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 6));
5829  _baseClassName = tmpMeta[1];
5830  _modifications = tmpMeta[2];
5831  _parts = tmpMeta[3];
5832  _ann = tmpMeta[4];
5833  /* Pattern matching succeeded */
5834 #line 5529 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5835  tmpMeta[1] = mmc_mk_box6(7, &Absyn_ClassDef_CLASS__EXTENDS__desc, _baseClassName, _modifications, mmc_mk_none(), _parts, _ann);
5836 #line 5529 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5837  tmpMeta[0] = tmpMeta[1];
5838 #line 5838 OMC_FILE
5839  goto tmp2_done;
5840  }
5841  case 4: {
5842  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,4) == 0) goto tmp2_end;
5843  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5844  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
5845  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
5846 
5847  _typeSpec = tmpMeta[1];
5848  _attributes = tmpMeta[2];
5849  _arguments = tmpMeta[3];
5850  /* Pattern matching succeeded */
5851 #line 5530 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5852  tmpMeta[1] = mmc_mk_box5(4, &Absyn_ClassDef_DERIVED__desc, _typeSpec, _attributes, _arguments, mmc_mk_none());
5853 #line 5530 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5854  tmpMeta[0] = tmpMeta[1];
5855 #line 5855 OMC_FILE
5856  goto tmp2_done;
5857  }
5858  case 5: {
5859  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
5860  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5861 
5862  _enumLiterals = tmpMeta[1];
5863  /* Pattern matching succeeded */
5864 #line 5531 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5865  tmpMeta[1] = mmc_mk_box3(5, &Absyn_ClassDef_ENUMERATION__desc, _enumLiterals, mmc_mk_none());
5866 #line 5531 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5867  tmpMeta[0] = tmpMeta[1];
5868 #line 5868 OMC_FILE
5869  goto tmp2_done;
5870  }
5871  case 6: {
5872  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,3,2) == 0) goto tmp2_end;
5873  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5874 
5875  _functionNames = tmpMeta[1];
5876  /* Pattern matching succeeded */
5877 #line 5532 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5878  tmpMeta[1] = mmc_mk_box3(6, &Absyn_ClassDef_OVERLOAD__desc, _functionNames, mmc_mk_none());
5879 #line 5532 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5880  tmpMeta[0] = tmpMeta[1];
5881 #line 5881 OMC_FILE
5882  goto tmp2_done;
5883  }
5884  case 8: {
5885  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,5,3) == 0) goto tmp2_end;
5886  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
5887  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
5888 
5889  _functionName = tmpMeta[1];
5890  _vars = tmpMeta[2];
5891  /* Pattern matching succeeded */
5892 #line 5533 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5893  tmpMeta[1] = mmc_mk_box4(8, &Absyn_ClassDef_PDER__desc, _functionName, _vars, mmc_mk_none());
5894 #line 5533 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5895  tmpMeta[0] = tmpMeta[1];
5896 #line 5896 OMC_FILE
5897  goto tmp2_done;
5898  }
5899  default:
5900  tmp2_default: OMC_LABEL_UNUSED; {
5901 
5902  /* Pattern matching succeeded */
5903 #line 5534 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
5904  tmpMeta[0] = _cl;
5905 #line 5905 OMC_FILE
5906  goto tmp2_done;
5907  }
5908  }
5909  goto tmp2_end;
5910  tmp2_end: ;
5911  }
5912  goto goto_1;
5913  goto_1:;
5914  MMC_THROW_INTERNAL();
5915  goto tmp2_done;
5916  tmp2_done:;
5917  }
5918  }
5919  _o = tmpMeta[0];
5920  _return: OMC_LABEL_UNUSED
5921  return _o;
5922 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassDef_DERIVED__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassDef_ENUMERATION__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassDef_CLASS__EXTENDS__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassDef_PARTS__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassDef_PDER__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassDef_OVERLOAD__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_stripFirst()

DLLExport modelica_metatype omc_Absyn_stripFirst ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 12159 of file Absyn.c.

12160 {
12161  modelica_metatype _outPath = NULL;
12162  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
12163  MMC_SO();
12164  _tailrecursive: OMC_LABEL_UNUSED
12165 #line 12165 OMC_FILE
12166  { /* match expression */
12167  modelica_metatype tmp3_1;
12168  tmp3_1 = _inPath;
12169  {
12170  modelica_metatype _p = NULL;
12171  volatile mmc_switch_type tmp3;
12172  int tmp4;
12173  tmp3 = 0;
12174  for (; tmp3 < 2; tmp3++) {
12175  switch (MMC_SWITCH_CAST(tmp3)) {
12176  case 0: {
12177  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
12178  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12179  _p = tmpMeta[1];
12180  /* Pattern matching succeeded */
12181 #line 3988 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12182  tmpMeta[0] = _p;
12183 #line 12183 OMC_FILE
12184  goto tmp2_done;
12185  }
12186  case 1: {
12187  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
12188  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12189  _p = tmpMeta[1];
12190  /* Pattern matching succeeded */
12191 #line 3989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12192  /* Tail recursive call */
12193 #line 3989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12194  _inPath = _p;
12195 #line 3989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12196  goto _tailrecursive;
12197 #line 3989 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12198  /* TODO: Make sure any eventual dead code below is never generated */
12199 #line 12199 OMC_FILE
12200  goto tmp2_done;
12201  }
12202  }
12203  goto tmp2_end;
12204  tmp2_end: ;
12205  }
12206  goto goto_1;
12207  goto_1:;
12208  MMC_THROW_INTERNAL();
12209  goto tmp2_done;
12210  tmp2_done:;
12211  }
12212  }
12213  _outPath = tmpMeta[0];
12214  _return: OMC_LABEL_UNUSED
12215  return _outPath;
12216 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_stripLast()

DLLExport modelica_metatype omc_Absyn_stripLast ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 12468 of file Absyn.c.

12469 {
12470  modelica_metatype _outPath = NULL;
12471  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
12472  MMC_SO();
12473  _tailrecursive: OMC_LABEL_UNUSED
12474 #line 12474 OMC_FILE
12475  { /* match expression */
12476  modelica_metatype tmp3_1;
12477  tmp3_1 = _inPath;
12478  {
12479  modelica_string _str = NULL;
12480  modelica_metatype _p = NULL;
12481  volatile mmc_switch_type tmp3;
12482  int tmp4;
12483  tmp3 = 0;
12484  for (; tmp3 < 3; tmp3++) {
12485  switch (MMC_SWITCH_CAST(tmp3)) {
12486  case 0: {
12487  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
12488  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12489  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12490  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],1,1) == 0) goto tmp2_end;
12491 
12492  _str = tmpMeta[1];
12493  /* Pattern matching succeeded */
12494 #line 3887 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12495  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _str);
12496 #line 3887 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12497  tmpMeta[0] = tmpMeta[1];
12498 #line 12498 OMC_FILE
12499  goto tmp2_done;
12500  }
12501  case 1: {
12502  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
12503  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12504  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
12505  _str = tmpMeta[1];
12506  _p = tmpMeta[2];
12507  /* Pattern matching succeeded */
12508 #line 3891 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12509  _p = omc_Absyn_stripLast(threadData, _p);
12510 #line 12510 OMC_FILE
12511 #line 3892 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12512  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _str, _p);
12513 #line 3892 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12514  tmpMeta[0] = tmpMeta[1];
12515 #line 12515 OMC_FILE
12516  goto tmp2_done;
12517  }
12518  case 2: {
12519  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
12520  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
12521  _p = tmpMeta[1];
12522  /* Pattern matching succeeded */
12523 #line 3897 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12524  _p = omc_Absyn_stripLast(threadData, _p);
12525 #line 12525 OMC_FILE
12526 #line 3898 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12527  tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _p);
12528 #line 3898 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12529  tmpMeta[0] = tmpMeta[1];
12530 #line 12530 OMC_FILE
12531  goto tmp2_done;
12532  }
12533  }
12534  goto tmp2_end;
12535  tmp2_end: ;
12536  }
12537  goto goto_1;
12538  goto_1:;
12539  MMC_THROW_INTERNAL();
12540  goto tmp2_done;
12541  tmp2_done:;
12542  }
12543  }
12544  _outPath = tmpMeta[0];
12545  _return: OMC_LABEL_UNUSED
12546  return _outPath;
12547 }
modelica_metatype modelica_string
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_FULLYQUALIFIED__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_stripLast(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:12468
Here is the caller graph for this function:

◆ omc_Absyn_stripLastOpt()

DLLExport modelica_metatype omc_Absyn_stripLastOpt ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 12414 of file Absyn.c.

12415 {
12416  modelica_metatype _outPath = NULL;
12417  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
12418  MMC_SO();
12419  _tailrecursive: OMC_LABEL_UNUSED
12420 #line 12420 OMC_FILE
12421  { /* match expression */
12422  modelica_metatype tmp3_1;
12423  tmp3_1 = _inPath;
12424  {
12425  modelica_metatype _p = NULL;
12426  volatile mmc_switch_type tmp3;
12427  int tmp4;
12428  tmp3 = 0;
12429  for (; tmp3 < 2; tmp3++) {
12430  switch (MMC_SWITCH_CAST(tmp3)) {
12431  case 0: {
12432  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
12433 
12434  /* Pattern matching succeeded */
12435 #line 3912 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12436  tmpMeta[0] = mmc_mk_none();
12437 #line 12437 OMC_FILE
12438  goto tmp2_done;
12439  }
12440  case 1: {
12441 
12442  /* Pattern matching succeeded */
12443 #line 3916 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12444  _p = omc_Absyn_stripLast(threadData, _inPath);
12445 #line 12445 OMC_FILE
12446 #line 3917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
12447  tmpMeta[0] = mmc_mk_some(_p);
12448 #line 12448 OMC_FILE
12449  goto tmp2_done;
12450  }
12451  }
12452  goto tmp2_end;
12453  tmp2_end: ;
12454  }
12455  goto goto_1;
12456  goto_1:;
12457  MMC_THROW_INTERNAL();
12458  goto tmp2_done;
12459  tmp2_done:;
12460  }
12461  }
12462  _outPath = tmpMeta[0];
12463  _return: OMC_LABEL_UNUSED
12464  return _outPath;
12465 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_stripLast(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:12468
Here is the call graph for this function:

◆ omc_Absyn_subModsInSameOrder()

DLLExport modelica_metatype omc_Absyn_subModsInSameOrder ( threadData_t threadData,
modelica_metatype  _oldmod,
modelica_metatype  _newmod 
)

Definition at line 4432 of file Absyn.c.

4433 {
4434  modelica_metatype _mod = NULL;
4435  modelica_metatype tmpMeta[8] __attribute__((unused)) = {0};
4436  MMC_SO();
4437  _tailrecursive: OMC_LABEL_UNUSED
4438 #line 4438 OMC_FILE
4439  { /* match expression */
4440  modelica_metatype tmp3_1;modelica_metatype tmp3_2;
4441  tmp3_1 = _oldmod;
4442  tmp3_2 = _newmod;
4443  {
4444  modelica_metatype _args1 = NULL;
4445  modelica_metatype _args2 = NULL;
4446  modelica_metatype _res = NULL;
4447  modelica_metatype _arg2 = NULL;
4448  modelica_metatype _eq2 = NULL;
4449  modelica_metatype _p = NULL;
4450  volatile mmc_switch_type tmp3;
4451  int tmp4;
4452  tmp3 = 0;
4453  for (; tmp3 < 3; tmp3++) {
4454  switch (MMC_SWITCH_CAST(tmp3)) {
4455  case 0: {
4456  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,6) == 0) goto tmp2_end;
4457  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 5));
4458  if (!optionNone(tmpMeta[1])) goto tmp2_end;
4459 
4460  /* Pattern matching succeeded */
4461 #line 5852 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4462  tmpMeta[0] = _newmod;
4463 #line 4463 OMC_FILE
4464  goto tmp2_done;
4465  }
4466  case 1: {
4467  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,6) == 0) goto tmp2_end;
4468  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
4469  if (!optionNone(tmpMeta[1])) goto tmp2_end;
4470 
4471  /* Pattern matching succeeded */
4472 #line 5853 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4473  tmpMeta[0] = _newmod;
4474 #line 4474 OMC_FILE
4475  goto tmp2_done;
4476  }
4477  case 2: {
4478  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,6) == 0) goto tmp2_end;
4479  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
4480  if (optionNone(tmpMeta[1])) goto tmp2_end;
4481  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
4482  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 2));
4483  if (mmc__uniontype__metarecord__typedef__equal(tmp3_2,0,6) == 0) goto tmp2_end;
4484  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_2), 5));
4485  if (optionNone(tmpMeta[4])) goto tmp2_end;
4486  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 1));
4487  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 2));
4488  tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[5]), 3));
4489 
4490  _args1 = tmpMeta[3];
4491  _arg2 = tmp3_2;
4492  _args2 = tmpMeta[6];
4493  _eq2 = tmpMeta[7];
4494  /* Pattern matching succeeded */
4495 #line 5858 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4496  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
4497 #line 5858 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4498  _res = tmpMeta[1];
4499 #line 4499 OMC_FILE
4500 
4501 #line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4502  {
4503 #line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4504  modelica_metatype _arg1;
4505 #line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4506  for (tmpMeta[1] = _args1; !listEmpty(tmpMeta[1]); tmpMeta[1]=MMC_CDR(tmpMeta[1]))
4507 #line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4508  {
4509 #line 5859 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4510  _arg1 = MMC_CAR(tmpMeta[1]);
4511 #line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4512  /* Pattern-matching assignment */
4513 #line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4514  tmpMeta[2] = _arg1;
4515 #line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4516  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[2],0,6) == 0) goto goto_1;
4517 #line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4518  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[2]), 4));
4519 #line 5860 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4520  _p = tmpMeta[3];
4521 #line 4521 OMC_FILE
4522 
4523 #line 5861 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4524  tmpMeta[2] = mmc_mk_box1(0, _p);
4525 #line 5861 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4526  if(omc_List_exist(threadData, _args2, (modelica_fnptr) mmc_mk_box2(0,closure3_Absyn_isModificationOfPath,tmpMeta[2])))
4527 #line 5861 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4528  {
4529 #line 5862 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4530  tmpMeta[3] = mmc_mk_cons(_arg1, _res);
4531 #line 5862 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4532  _res = tmpMeta[3];
4533 #line 4533 OMC_FILE
4534  }
4535  }
4536  }
4537 
4538 #line 5865 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4539  _res = listReverse(_res);
4540 #line 4540 OMC_FILE
4541 
4542 #line 5867 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4543  _res = omc_Absyn_mergeAnnotations2(threadData, _res, _args2);
4544 #line 4544 OMC_FILE
4545 
4546 #line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4547  tmpMeta[2] = mmc_mk_box3(3, &Absyn_Modification_CLASSMOD__desc, _res, _eq2);
4548 #line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4549  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(8));
4550 #line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4551  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_arg2), 8*sizeof(modelica_metatype));
4552 #line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4553  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[5] = mmc_mk_some(tmpMeta[2]);
4554 #line 5868 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4555  _arg2 = tmpMeta[1];
4556 #line 4556 OMC_FILE
4557 #line 5869 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4558  tmpMeta[0] = _arg2;
4559 #line 4559 OMC_FILE
4560  goto tmp2_done;
4561  }
4562  }
4563  goto tmp2_end;
4564  tmp2_end: ;
4565  }
4566  goto goto_1;
4567  goto_1:;
4568  MMC_THROW_INTERNAL();
4569  goto tmp2_done;
4570  tmp2_done:;
4571  }
4572  }
4573  _mod = tmpMeta[0];
4574  _return: OMC_LABEL_UNUSED
4575  return _mod;
4576 }
float mmc_switch_type
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Modification_CLASSMOD__desc
void * modelica_metatype
modelica_metatype listReverse(modelica_metatype)
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_mergeAnnotations2(threadData_t *threadData, modelica_metatype _oldmods, modelica_metatype _newmods)
Definition: Absyn.c:4733
DLLExport modelica_boolean omc_List_exist(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFindFunc)
Definition: List.c:4740
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
int line
Definition: de.c:117

◆ omc_Absyn_subscriptEqual()

DLLExport modelica_boolean omc_Absyn_subscriptEqual ( threadData_t threadData,
modelica_metatype  _inSubscript1,
modelica_metatype  _inSubscript2 
)

Definition at line 9857 of file Absyn.c.

9858 {
9859  modelica_boolean _outIsEqual;
9860  modelica_boolean tmp1 = 0;
9861  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
9862  MMC_SO();
9863  _tailrecursive: OMC_LABEL_UNUSED
9864 #line 9864 OMC_FILE
9865  { /* match expression */
9866  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
9867  tmp4_1 = _inSubscript1;
9868  tmp4_2 = _inSubscript2;
9869  {
9870  modelica_metatype _e1 = NULL;
9871  modelica_metatype _e2 = NULL;
9872  volatile mmc_switch_type tmp4;
9873  int tmp5;
9874  tmp4 = 0;
9875  for (; tmp4 < 3; tmp4++) {
9876  switch (MMC_SWITCH_CAST(tmp4)) {
9877  case 0: {
9878  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
9879  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,0) == 0) goto tmp3_end;
9880  /* Pattern matching succeeded */
9881 #line 4556 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9882  tmp1 = 1;
9883 #line 9883 OMC_FILE
9884  goto tmp3_done;
9885  }
9886  case 1: {
9887  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
9888  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
9889  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,1) == 0) goto tmp3_end;
9890  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
9891  _e1 = tmpMeta[0];
9892  _e2 = tmpMeta[1];
9893  /* Pattern matching succeeded */
9894 #line 4557 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9895  tmp1 = omc_Absyn_expEqual(threadData, _e1, _e2);
9896 #line 9896 OMC_FILE
9897  goto tmp3_done;
9898  }
9899  case 2: {
9900 
9901  /* Pattern matching succeeded */
9902 #line 4558 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9903  tmp1 = 0;
9904 #line 9904 OMC_FILE
9905  goto tmp3_done;
9906  }
9907  }
9908  goto tmp3_end;
9909  tmp3_end: ;
9910  }
9911  goto goto_2;
9912  goto_2:;
9913  MMC_THROW_INTERNAL();
9914  goto tmp3_done;
9915  tmp3_done:;
9916  }
9917  }
9918  _outIsEqual = tmp1;
9919  _return: OMC_LABEL_UNUSED
9920  return _outIsEqual;
9921 }
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_Absyn_expEqual(threadData_t *threadData, modelica_metatype _exp1, modelica_metatype _exp2)
Definition: Absyn.c:9490
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_subscriptExpOpt()

DLLExport modelica_metatype omc_Absyn_subscriptExpOpt ( threadData_t threadData,
modelica_metatype  _inSub 
)

Definition at line 7061 of file Absyn.c.

7062 {
7063  modelica_metatype _outExpOpt = NULL;
7064  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
7065  MMC_SO();
7066  _tailrecursive: OMC_LABEL_UNUSED
7067 #line 7067 OMC_FILE
7068  { /* match expression */
7069  modelica_metatype tmp3_1;
7070  tmp3_1 = _inSub;
7071  {
7072  modelica_metatype _e = NULL;
7073  volatile mmc_switch_type tmp3;
7074  int tmp4;
7075  tmp3 = 0;
7076  for (; tmp3 < 2; tmp3++) {
7077  switch (MMC_SWITCH_CAST(tmp3)) {
7078  case 0: {
7079  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
7080  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
7081  _e = tmpMeta[1];
7082  /* Pattern matching succeeded */
7083 #line 5251 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7084  tmpMeta[0] = mmc_mk_some(_e);
7085 #line 7085 OMC_FILE
7086  goto tmp2_done;
7087  }
7088  case 1: {
7089  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,0) == 0) goto tmp2_end;
7090  /* Pattern matching succeeded */
7091 #line 5252 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7092  tmpMeta[0] = mmc_mk_none();
7093 #line 7093 OMC_FILE
7094  goto tmp2_done;
7095  }
7096  }
7097  goto tmp2_end;
7098  tmp2_end: ;
7099  }
7100  goto goto_1;
7101  goto_1:;
7102  MMC_THROW_INTERNAL();
7103  goto tmp2_done;
7104  tmp2_done:;
7105  }
7106  }
7107  _outExpOpt = tmpMeta[0];
7108  _return: OMC_LABEL_UNUSED
7109  return _outExpOpt;
7110 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_subscriptsEqual()

DLLExport modelica_boolean omc_Absyn_subscriptsEqual ( threadData_t threadData,
modelica_metatype  _inSubList1,
modelica_metatype  _inSubList2 
)

Definition at line 9836 of file Absyn.c.

9837 {
9838  modelica_boolean _outIsEqual;
9839  MMC_SO();
9840  _tailrecursive: OMC_LABEL_UNUSED
9841 #line 4568 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
9842  _outIsEqual = omc_List_isEqualOnTrue(threadData, _inSubList1, _inSubList2, boxvar_Absyn_subscriptEqual);
9843 #line 9843 OMC_FILE
9844  _return: OMC_LABEL_UNUSED
9845  return _outIsEqual;
9846 }
signed char modelica_boolean
DLLExport modelica_boolean omc_List_isEqualOnTrue(threadData_t *threadData, modelica_metatype _inList1, modelica_metatype _inList2, modelica_fnptr _inCompFunc)
Definition: List.c:18331
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_suffixPath()

DLLExport modelica_metatype omc_Absyn_suffixPath ( threadData_t threadData,
modelica_metatype  _inPath,
modelica_string  _inSuffix 
)

Definition at line 15126 of file Absyn.c.

15127 {
15128  modelica_metatype _outPath = NULL;
15129  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
15130  MMC_SO();
15131  _tailrecursive: OMC_LABEL_UNUSED
15132 #line 15132 OMC_FILE
15133  { /* match expression */
15134  modelica_metatype tmp3_1;
15135  tmp3_1 = _inPath;
15136  {
15137  modelica_string _name = NULL;
15138  modelica_metatype _path = NULL;
15139  int tmp3;
15140  {
15141  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
15142  case 4: {
15143  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,1) == 0) goto tmp2_end;
15144  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15145  _name = tmpMeta[1];
15146  /* Pattern matching succeeded */
15147 #line 3116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15148  tmpMeta[1] = mmc_mk_box2(4, &Absyn_Path_IDENT__desc, _inSuffix);
15149 #line 3116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15150  tmpMeta[2] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _name, tmpMeta[1]);
15151 #line 3116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15152  tmpMeta[0] = tmpMeta[2];
15153 #line 15153 OMC_FILE
15154  goto tmp2_done;
15155  }
15156  case 3: {
15157  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
15158  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15159  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
15160  _name = tmpMeta[1];
15161  _path = tmpMeta[2];
15162  /* Pattern matching succeeded */
15163 #line 3120 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15164  _path = omc_Absyn_suffixPath(threadData, _path, _inSuffix);
15165 #line 15165 OMC_FILE
15166 #line 3121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15167  tmpMeta[1] = mmc_mk_box3(3, &Absyn_Path_QUALIFIED__desc, _name, _path);
15168 #line 3121 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15169  tmpMeta[0] = tmpMeta[1];
15170 #line 15170 OMC_FILE
15171  goto tmp2_done;
15172  }
15173  case 5: {
15174  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,1) == 0) goto tmp2_end;
15175  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
15176  _path = tmpMeta[1];
15177  /* Pattern matching succeeded */
15178 #line 3126 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15179  _path = omc_Absyn_suffixPath(threadData, _path, _inSuffix);
15180 #line 15180 OMC_FILE
15181 #line 3127 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15182  tmpMeta[1] = mmc_mk_box2(5, &Absyn_Path_FULLYQUALIFIED__desc, _path);
15183 #line 3127 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
15184  tmpMeta[0] = tmpMeta[1];
15185 #line 15185 OMC_FILE
15186  goto tmp2_done;
15187  }
15188  }
15189  goto tmp2_end;
15190  tmp2_end: ;
15191  }
15192  goto goto_1;
15193  goto_1:;
15194  MMC_THROW_INTERNAL();
15195  goto tmp2_done;
15196  tmp2_done:;
15197  }
15198  }
15199  _outPath = tmpMeta[0];
15200  _return: OMC_LABEL_UNUSED
15201  return _outPath;
15202 }
modelica_metatype modelica_string
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_IDENT__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_FULLYQUALIFIED__desc
DLLExport modelica_metatype omc_Absyn_suffixPath(threadData_t *threadData, modelica_metatype _inPath, modelica_string _inSuffix)
Definition: Absyn.c:15126
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Path_QUALIFIED__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_traverseAlgorithm()

DLLExport modelica_metatype omc_Absyn_traverseAlgorithm ( threadData_t threadData,
modelica_metatype  _inAlgorithm,
modelica_fnptr  _inFunc,
modelica_metatype  _inTypeA 
)

Definition at line 21232 of file Absyn.c.

21233 {
21234  modelica_metatype _outTpl = NULL;
21235  modelica_metatype tmpMeta[7] __attribute__((unused)) = {0};
21236  MMC_SO();
21237  _tailrecursive: OMC_LABEL_UNUSED
21238 #line 21238 OMC_FILE
21239  { /* matchcontinue expression */
21240  volatile modelica_metatype tmp3_1;volatile modelica_fnptr tmp3_2;volatile modelica_metatype tmp3_3;
21241  tmp3_1 = _inAlgorithm;
21242  tmp3_2 = ((modelica_fnptr) _inFunc);
21243  tmp3_3 = _inTypeA;
21244  {
21245  modelica_metatype _arg = NULL;
21246  modelica_metatype _arg_1 = NULL;
21247  modelica_metatype _arg1_1 = NULL;
21248  modelica_metatype _arg2_1 = NULL;
21249  modelica_metatype _arg3_1 = NULL;
21250  modelica_metatype _alg = NULL;
21251  modelica_metatype _alg_1 = NULL;
21252  modelica_metatype _ailst = NULL;
21253  modelica_metatype _ailst1 = NULL;
21254  modelica_metatype _ailst2 = NULL;
21255  modelica_metatype _ailst_1 = NULL;
21256  modelica_metatype _ailst1_1 = NULL;
21257  modelica_metatype _ailst2_1 = NULL;
21258  modelica_metatype _eaitlst = NULL;
21259  modelica_metatype _eaitlst_1 = NULL;
21260  modelica_fnptr _rel;
21261  modelica_metatype _e_1 = NULL;
21262  modelica_metatype _fis_1 = NULL;
21263  volatile mmc_switch_type tmp3;
21264  int tmp4;
21265  tmp3 = 0;
21266  MMC_TRY_INTERNAL(mmc_jumper)
21267  tmp2_top:
21268  threadData->mmc_jumper = &new_mmc_jumper;
21269  for (; tmp3 < 6; tmp3++) {
21270  switch (MMC_SWITCH_CAST(tmp3)) {
21271  case 0: {
21272  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,4) == 0) goto tmp2_end;
21273  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
21274  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
21275  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
21276 
21277  _alg = tmp3_1;
21278  _ailst1 = tmpMeta[1];
21279  _eaitlst = tmpMeta[2];
21280  _ailst2 = tmpMeta[3];
21281  _rel = tmp3_2;
21282  _arg = tmp3_3;
21283  tmp3 += 4; /* Pattern matching succeeded; we may skip some cases if we fail */
21284 #line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21285  /* Pattern-matching assignment */
21286 #line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21287  tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst1, ((modelica_fnptr) _rel), _arg);
21288 #line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21289  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21290 #line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21291  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21292 #line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21293  _ailst1_1 = tmpMeta[2];
21294 #line 1306 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21295  _arg1_1 = tmpMeta[3];
21296 #line 21296 OMC_FILE
21297 
21298 #line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21299  /* Pattern-matching assignment */
21300 #line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21301  tmpMeta[1] = omc_Absyn_traverseExpAlgItemTupleList(threadData, _eaitlst, ((modelica_fnptr) _rel), _arg1_1);
21302 #line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21303  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21304 #line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21305  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21306 #line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21307  _eaitlst_1 = tmpMeta[2];
21308 #line 1307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21309  _arg2_1 = tmpMeta[3];
21310 #line 21310 OMC_FILE
21311 
21312 #line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21313  /* Pattern-matching assignment */
21314 #line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21315  tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst2, ((modelica_fnptr) _rel), _arg2_1);
21316 #line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21317  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21318 #line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21319  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21320 #line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21321  _ailst2_1 = tmpMeta[2];
21322 #line 1308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21323  _arg3_1 = tmpMeta[3];
21324 #line 21324 OMC_FILE
21325 
21326 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21327  /* Pattern-matching assignment */
21328 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21329  tmpMeta[1] = mmc_mk_box2(0, _alg, _arg3_1);
21330 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21331  tmpMeta[2] = mmc_mk_box2(0, _alg, _arg3_1);
21332 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21333  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
21334 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21335  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
21336 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21337  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],1,4) == 0) goto goto_1;
21338 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21339  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
21340 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21341  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
21342 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21343  _e_1 = tmpMeta[5];
21344 #line 1309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21345  _arg_1 = tmpMeta[6];
21346 #line 21346 OMC_FILE
21347 #line 1310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21348  tmpMeta[1] = mmc_mk_box5(4, &Absyn_Algorithm_ALG__IF__desc, _e_1, _ailst1_1, _eaitlst_1, _ailst2_1);
21349 #line 1310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21350  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
21351 #line 1310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21352  tmpMeta[0] = tmpMeta[2];
21353 #line 21353 OMC_FILE
21354  goto tmp2_done;
21355  }
21356  case 1: {
21357  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,2,2) == 0) goto tmp2_end;
21358  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
21359 
21360  _alg = tmp3_1;
21361  _ailst = tmpMeta[1];
21362  _rel = tmp3_2;
21363  _arg = tmp3_3;
21364  tmp3 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
21365 #line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21366  /* Pattern-matching assignment */
21367 #line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21368  tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
21369 #line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21370  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21371 #line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21372  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21373 #line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21374  _ailst_1 = tmpMeta[2];
21375 #line 1314 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21376  _arg1_1 = tmpMeta[3];
21377 #line 21377 OMC_FILE
21378 
21379 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21380  /* Pattern-matching assignment */
21381 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21382  tmpMeta[1] = mmc_mk_box2(0, _alg, _arg1_1);
21383 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21384  tmpMeta[2] = mmc_mk_box2(0, _alg, _arg1_1);
21385 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21386  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
21387 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21388  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
21389 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21390  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],2,2) == 0) goto goto_1;
21391 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21392  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
21393 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21394  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
21395 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21396  _fis_1 = tmpMeta[5];
21397 #line 1315 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21398  _arg_1 = tmpMeta[6];
21399 #line 21399 OMC_FILE
21400 #line 1316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21401  tmpMeta[1] = mmc_mk_box3(5, &Absyn_Algorithm_ALG__FOR__desc, _fis_1, _ailst_1);
21402 #line 1316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21403  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
21404 #line 1316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21405  tmpMeta[0] = tmpMeta[2];
21406 #line 21406 OMC_FILE
21407  goto tmp2_done;
21408  }
21409  case 2: {
21410  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,3,2) == 0) goto tmp2_end;
21411  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
21412 
21413  _alg = tmp3_1;
21414  _ailst = tmpMeta[1];
21415  _rel = tmp3_2;
21416  _arg = tmp3_3;
21417  tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
21418 #line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21419  /* Pattern-matching assignment */
21420 #line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21421  tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
21422 #line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21423  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21424 #line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21425  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21426 #line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21427  _ailst_1 = tmpMeta[2];
21428 #line 1320 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21429  _arg1_1 = tmpMeta[3];
21430 #line 21430 OMC_FILE
21431 
21432 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21433  /* Pattern-matching assignment */
21434 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21435  tmpMeta[1] = mmc_mk_box2(0, _alg, _arg1_1);
21436 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21437  tmpMeta[2] = mmc_mk_box2(0, _alg, _arg1_1);
21438 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21439  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
21440 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21441  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
21442 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21443  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],3,2) == 0) goto goto_1;
21444 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21445  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
21446 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21447  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
21448 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21449  _fis_1 = tmpMeta[5];
21450 #line 1321 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21451  _arg_1 = tmpMeta[6];
21452 #line 21452 OMC_FILE
21453 #line 1322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21454  tmpMeta[1] = mmc_mk_box3(6, &Absyn_Algorithm_ALG__PARFOR__desc, _fis_1, _ailst_1);
21455 #line 1322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21456  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
21457 #line 1322 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21458  tmpMeta[0] = tmpMeta[2];
21459 #line 21459 OMC_FILE
21460  goto tmp2_done;
21461  }
21462  case 3: {
21463  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,4,2) == 0) goto tmp2_end;
21464  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
21465 
21466  _alg = tmp3_1;
21467  _ailst = tmpMeta[1];
21468  _rel = tmp3_2;
21469  _arg = tmp3_3;
21470  tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
21471 #line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21472  /* Pattern-matching assignment */
21473 #line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21474  tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
21475 #line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21476  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21477 #line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21478  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21479 #line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21480  _ailst_1 = tmpMeta[2];
21481 #line 1326 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21482  _arg1_1 = tmpMeta[3];
21483 #line 21483 OMC_FILE
21484 
21485 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21486  /* Pattern-matching assignment */
21487 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21488  tmpMeta[1] = mmc_mk_box2(0, _alg, _arg1_1);
21489 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21490  tmpMeta[2] = mmc_mk_box2(0, _alg, _arg1_1);
21491 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21492  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
21493 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21494  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
21495 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21496  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],4,2) == 0) goto goto_1;
21497 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21498  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
21499 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21500  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
21501 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21502  _e_1 = tmpMeta[5];
21503 #line 1327 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21504  _arg_1 = tmpMeta[6];
21505 #line 21505 OMC_FILE
21506 #line 1328 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21507  tmpMeta[1] = mmc_mk_box3(7, &Absyn_Algorithm_ALG__WHILE__desc, _e_1, _ailst_1);
21508 #line 1328 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21509  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
21510 #line 1328 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21511  tmpMeta[0] = tmpMeta[2];
21512 #line 21512 OMC_FILE
21513  goto tmp2_done;
21514  }
21515  case 4: {
21516  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,5,3) == 0) goto tmp2_end;
21517  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
21518  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
21519 
21520  _alg = tmp3_1;
21521  _ailst = tmpMeta[1];
21522  _eaitlst = tmpMeta[2];
21523  _rel = tmp3_2;
21524  _arg = tmp3_3;
21525  /* Pattern matching succeeded */
21526 #line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21527  /* Pattern-matching assignment */
21528 #line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21529  tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
21530 #line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21531  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21532 #line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21533  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21534 #line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21535  _ailst_1 = tmpMeta[2];
21536 #line 1332 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21537  _arg1_1 = tmpMeta[3];
21538 #line 21538 OMC_FILE
21539 
21540 #line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21541  /* Pattern-matching assignment */
21542 #line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21543  tmpMeta[1] = omc_Absyn_traverseExpAlgItemTupleList(threadData, _eaitlst, ((modelica_fnptr) _rel), _arg1_1);
21544 #line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21545  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21546 #line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21547  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21548 #line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21549  _eaitlst_1 = tmpMeta[2];
21550 #line 1333 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21551  _arg2_1 = tmpMeta[3];
21552 #line 21552 OMC_FILE
21553 
21554 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21555  /* Pattern-matching assignment */
21556 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21557  tmpMeta[1] = mmc_mk_box2(0, _alg, _arg2_1);
21558 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21559  tmpMeta[2] = mmc_mk_box2(0, _alg, _arg2_1);
21560 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21561  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
21562 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21563  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
21564 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21565  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],5,3) == 0) goto goto_1;
21566 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21567  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
21568 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21569  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
21570 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21571  _e_1 = tmpMeta[5];
21572 #line 1334 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21573  _arg_1 = tmpMeta[6];
21574 #line 21574 OMC_FILE
21575 #line 1335 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21576  tmpMeta[1] = mmc_mk_box4(8, &Absyn_Algorithm_ALG__WHEN__A__desc, _e_1, _ailst_1, _eaitlst_1);
21577 #line 1335 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21578  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
21579 #line 1335 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21580  tmpMeta[0] = tmpMeta[2];
21581 #line 21581 OMC_FILE
21582  goto tmp2_done;
21583  }
21584  case 5: {
21585 
21586  _alg = tmp3_1;
21587  _rel = tmp3_2;
21588  _arg = tmp3_3;
21589  /* Pattern matching succeeded */
21590 #line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21591  /* Pattern-matching assignment */
21592 #line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21593  tmpMeta[1] = mmc_mk_box2(0, _alg, _arg);
21594 #line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21595  tmpMeta[2] = mmc_mk_box2(0, _alg, _arg);
21596 #line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21597  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
21598 #line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21599  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
21600 #line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21601  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
21602 #line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21603  _alg_1 = tmpMeta[4];
21604 #line 1339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21605  _arg_1 = tmpMeta[5];
21606 #line 21606 OMC_FILE
21607 #line 1340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21608  tmpMeta[1] = mmc_mk_box2(0, _alg_1, _arg_1);
21609 #line 1340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21610  tmpMeta[0] = tmpMeta[1];
21611 #line 21611 OMC_FILE
21612  goto tmp2_done;
21613  }
21614  }
21615  goto tmp2_end;
21616  tmp2_end: ;
21617  }
21618  goto goto_1;
21619  tmp2_done:
21620  (void)tmp3;
21621  MMC_RESTORE_INTERNAL(mmc_jumper);
21622  goto tmp2_done2;
21623  goto_1:;
21624  MMC_CATCH_INTERNAL(mmc_jumper);
21625  if (++tmp3 < 6) {
21626  goto tmp2_top;
21627  }
21628  MMC_THROW_INTERNAL();
21629  tmp2_done2:;
21630  }
21631  }
21632  _outTpl = tmpMeta[0];
21633  _return: OMC_LABEL_UNUSED
21634  return _outTpl;
21635 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__IF__desc
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
float mmc_switch_type
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__WHILE__desc
DLLExport modelica_metatype omc_Absyn_traverseExpAlgItemTupleList(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:20921
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__WHEN__A__desc
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__PARFOR__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__FOR__desc
DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItemList(threadData_t *threadData, modelica_metatype _inAlgorithmItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21030
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseAlgorithmBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmBidir ( threadData_t threadData,
modelica_metatype  _inAlg,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 18244 of file Absyn.c.

18245 {
18246  modelica_metatype _outAlg = NULL;
18247  modelica_metatype _outArg = NULL;
18248  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
18249  MMC_SO();
18250  _tailrecursive: OMC_LABEL_UNUSED
18251 #line 2325 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18252 
18253 #line 2325 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18254 
18255 #line 18255 OMC_FILE
18256  { /* match expression */
18257  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
18258  tmp4_1 = _inAlg;
18259  tmp4_2 = _inArg;
18260  {
18261  modelica_metatype _arg = NULL;
18262  modelica_metatype _e1 = NULL;
18263  modelica_metatype _e2 = NULL;
18264  modelica_metatype _algs1 = NULL;
18265  modelica_metatype _algs2 = NULL;
18266  modelica_metatype _else_branch = NULL;
18267  modelica_metatype _cref1 = NULL;
18268  modelica_metatype _iters = NULL;
18269  modelica_metatype _func_args = NULL;
18270  int tmp4;
18271  {
18272  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
18273  case 3: {
18274  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
18275  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18276  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18277 
18278  _e1 = tmpMeta[2];
18279  _e2 = tmpMeta[3];
18280  _arg = tmp4_2;
18281  /* Pattern matching succeeded */
18282 #line 2338 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18283  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18284 #line 18284 OMC_FILE
18285 
18286 #line 2339 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18287  _e2 = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18288 #line 18288 OMC_FILE
18289 #line 2340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18290  tmpMeta[2] = mmc_mk_box3(3, &Absyn_Algorithm_ALG__ASSIGN__desc, _e1, _e2);
18291 #line 2340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18292  tmpMeta[0+0] = tmpMeta[2];
18293 #line 2340 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18294  tmpMeta[0+1] = _arg;
18295 #line 18295 OMC_FILE
18296  goto tmp3_done;
18297  }
18298  case 4: {
18299  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,4) == 0) goto tmp3_end;
18300  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18301  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18302  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
18303  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
18304 
18305  _e1 = tmpMeta[2];
18306  _algs1 = tmpMeta[3];
18307  _else_branch = tmpMeta[4];
18308  _algs2 = tmpMeta[5];
18309  _arg = tmp4_2;
18310  /* Pattern matching succeeded */
18311 #line 2345 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18312  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18313 #line 18313 OMC_FILE
18314 
18315 #line 2346 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18316  _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18317 #line 18317 OMC_FILE
18318 
18319 #line 2347 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18320  _else_branch = omc_List_map2FoldCheckReferenceEq(threadData, _else_branch, boxvar_Absyn_traverseAlgorithmBidirElse, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18321 #line 18321 OMC_FILE
18322 
18323 #line 2348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18324  _algs2 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18325 #line 18325 OMC_FILE
18326 #line 2349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18327  tmpMeta[2] = mmc_mk_box5(4, &Absyn_Algorithm_ALG__IF__desc, _e1, _algs1, _else_branch, _algs2);
18328 #line 2349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18329  tmpMeta[0+0] = tmpMeta[2];
18330 #line 2349 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18331  tmpMeta[0+1] = _arg;
18332 #line 18332 OMC_FILE
18333  goto tmp3_done;
18334  }
18335  case 5: {
18336  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
18337  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18338  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18339 
18340  _iters = tmpMeta[2];
18341  _algs1 = tmpMeta[3];
18342  _arg = tmp4_2;
18343  /* Pattern matching succeeded */
18344 #line 2353 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18345  _iters = omc_List_map2FoldCheckReferenceEq(threadData, _iters, boxvar_Absyn_traverseExpBidirIterator, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18346 #line 18346 OMC_FILE
18347 
18348 #line 2354 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18349  _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18350 #line 18350 OMC_FILE
18351 #line 2355 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18352  tmpMeta[2] = mmc_mk_box3(5, &Absyn_Algorithm_ALG__FOR__desc, _iters, _algs1);
18353 #line 2355 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18354  tmpMeta[0+0] = tmpMeta[2];
18355 #line 2355 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18356  tmpMeta[0+1] = _arg;
18357 #line 18357 OMC_FILE
18358  goto tmp3_done;
18359  }
18360  case 6: {
18361  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,2) == 0) goto tmp3_end;
18362  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18363  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18364 
18365  _iters = tmpMeta[2];
18366  _algs1 = tmpMeta[3];
18367  _arg = tmp4_2;
18368  /* Pattern matching succeeded */
18369 #line 2359 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18370  _iters = omc_List_map2FoldCheckReferenceEq(threadData, _iters, boxvar_Absyn_traverseExpBidirIterator, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18371 #line 18371 OMC_FILE
18372 
18373 #line 2360 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18374  _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18375 #line 18375 OMC_FILE
18376 #line 2361 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18377  tmpMeta[2] = mmc_mk_box3(6, &Absyn_Algorithm_ALG__PARFOR__desc, _iters, _algs1);
18378 #line 2361 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18379  tmpMeta[0+0] = tmpMeta[2];
18380 #line 2361 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18381  tmpMeta[0+1] = _arg;
18382 #line 18382 OMC_FILE
18383  goto tmp3_done;
18384  }
18385  case 7: {
18386  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,2) == 0) goto tmp3_end;
18387  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18388  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18389 
18390  _e1 = tmpMeta[2];
18391  _algs1 = tmpMeta[3];
18392  _arg = tmp4_2;
18393  /* Pattern matching succeeded */
18394 #line 2365 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18395  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18396 #line 18396 OMC_FILE
18397 
18398 #line 2366 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18399  _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18400 #line 18400 OMC_FILE
18401 #line 2367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18402  tmpMeta[2] = mmc_mk_box3(7, &Absyn_Algorithm_ALG__WHILE__desc, _e1, _algs1);
18403 #line 2367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18404  tmpMeta[0+0] = tmpMeta[2];
18405 #line 2367 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18406  tmpMeta[0+1] = _arg;
18407 #line 18407 OMC_FILE
18408  goto tmp3_done;
18409  }
18410  case 8: {
18411  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,3) == 0) goto tmp3_end;
18412  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18413  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18414  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
18415 
18416  _e1 = tmpMeta[2];
18417  _algs1 = tmpMeta[3];
18418  _else_branch = tmpMeta[4];
18419  _arg = tmp4_2;
18420  /* Pattern matching succeeded */
18421 #line 2371 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18422  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18423 #line 18423 OMC_FILE
18424 
18425 #line 2372 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18426  _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18427 #line 18427 OMC_FILE
18428 
18429 #line 2373 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18430  _else_branch = omc_List_map2FoldCheckReferenceEq(threadData, _else_branch, boxvar_Absyn_traverseAlgorithmBidirElse, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18431 #line 18431 OMC_FILE
18432 #line 2374 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18433  tmpMeta[2] = mmc_mk_box4(8, &Absyn_Algorithm_ALG__WHEN__A__desc, _e1, _algs1, _else_branch);
18434 #line 2374 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18435  tmpMeta[0+0] = tmpMeta[2];
18436 #line 2374 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18437  tmpMeta[0+1] = _arg;
18438 #line 18438 OMC_FILE
18439  goto tmp3_done;
18440  }
18441  case 9: {
18442  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
18443  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18444  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18445 
18446  _cref1 = tmpMeta[2];
18447  _func_args = tmpMeta[3];
18448  _arg = tmp4_2;
18449  /* Pattern matching succeeded */
18450 #line 2378 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18451  _cref1 = omc_Absyn_traverseExpBidirCref(threadData, _cref1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18452 #line 18452 OMC_FILE
18453 
18454 #line 2379 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18455  _func_args = omc_Absyn_traverseExpBidirFunctionArgs(threadData, _func_args, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18456 #line 18456 OMC_FILE
18457 #line 2380 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18458  tmpMeta[2] = mmc_mk_box3(9, &Absyn_Algorithm_ALG__NORETCALL__desc, _cref1, _func_args);
18459 #line 2380 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18460  tmpMeta[0+0] = tmpMeta[2];
18461 #line 2380 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18462  tmpMeta[0+1] = _arg;
18463 #line 18463 OMC_FILE
18464  goto tmp3_done;
18465  }
18466  case 10: {
18467  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,0) == 0) goto tmp3_end;
18468 
18469  _arg = tmp4_2;
18470  /* Pattern matching succeeded */
18471 #line 2384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18472  tmpMeta[0+0] = _inAlg;
18473 #line 2384 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18474  tmpMeta[0+1] = _arg;
18475 #line 18475 OMC_FILE
18476  goto tmp3_done;
18477  }
18478  case 11: {
18479  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,0) == 0) goto tmp3_end;
18480 
18481  _arg = tmp4_2;
18482  /* Pattern matching succeeded */
18483 #line 2387 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18484  tmpMeta[0+0] = _inAlg;
18485 #line 2387 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18486  tmpMeta[0+1] = _arg;
18487 #line 18487 OMC_FILE
18488  goto tmp3_done;
18489  }
18490  case 14: {
18491  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,0) == 0) goto tmp3_end;
18492 
18493  _arg = tmp4_2;
18494  /* Pattern matching succeeded */
18495 #line 2390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18496  tmpMeta[0+0] = _inAlg;
18497 #line 2390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18498  tmpMeta[0+1] = _arg;
18499 #line 18499 OMC_FILE
18500  goto tmp3_done;
18501  }
18502  case 12: {
18503  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,1) == 0) goto tmp3_end;
18504  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18505 
18506  _algs1 = tmpMeta[2];
18507  _arg = tmp4_2;
18508  /* Pattern matching succeeded */
18509 #line 2394 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18510  _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18511 #line 18511 OMC_FILE
18512 #line 2395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18513  tmpMeta[2] = mmc_mk_box2(12, &Absyn_Algorithm_ALG__FAILURE__desc, _algs1);
18514 #line 2395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18515  tmpMeta[0+0] = tmpMeta[2];
18516 #line 2395 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18517  tmpMeta[0+1] = _arg;
18518 #line 18518 OMC_FILE
18519  goto tmp3_done;
18520  }
18521  case 13: {
18522  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,10,2) == 0) goto tmp3_end;
18523  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18524  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18525 
18526  _algs1 = tmpMeta[2];
18527  _algs2 = tmpMeta[3];
18528  _arg = tmp4_2;
18529  /* Pattern matching succeeded */
18530 #line 2400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18531  _algs1 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18532 #line 18532 OMC_FILE
18533 
18534 #line 2401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18535  _algs2 = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18536 #line 18536 OMC_FILE
18537 #line 2402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18538  tmpMeta[2] = mmc_mk_box3(13, &Absyn_Algorithm_ALG__TRY__desc, _algs1, _algs2);
18539 #line 2402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18540  tmpMeta[0+0] = tmpMeta[2];
18541 #line 2402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18542  tmpMeta[0+1] = _arg;
18543 #line 18543 OMC_FILE
18544  goto tmp3_done;
18545  }
18546  }
18547  goto tmp3_end;
18548  tmp3_end: ;
18549  }
18550  goto goto_2;
18551  goto_2:;
18552  MMC_THROW_INTERNAL();
18553  goto tmp3_done;
18554  tmp3_done:;
18555  }
18556  }
18557  _outAlg = tmpMeta[0+0];
18558  _outArg = tmpMeta[0+1];
18559  _return: OMC_LABEL_UNUSED
18560  if (out_outArg) { *out_outArg = _outArg; }
18561  return _outAlg;
18562 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__IF__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__FAILURE__desc
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__WHILE__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__WHEN__A__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__NORETCALL__desc
DLLExport modelica_metatype omc_Absyn_traverseExpBidirCref(threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:19702
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmItemListBidir(threadData_t *threadData, modelica_metatype _inAlgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:19059
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__PARFOR__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__FOR__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__ASSIGN__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__TRY__desc
DLLExport modelica_metatype omc_Absyn_traverseExpBidirFunctionArgs(threadData_t *threadData, modelica_metatype _inArgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:19426
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseAlgorithmBidirElse()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmBidirElse ( threadData_t threadData,
modelica_metatype  _inElse,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_arg 
)

Definition at line 18564 of file Absyn.c.

18565 {
18566  modelica_metatype _outElse = NULL;
18567  modelica_metatype _arg = NULL;
18568  modelica_metatype _e = NULL;
18569  modelica_metatype _algs = NULL;
18570  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
18571  MMC_SO();
18572  _tailrecursive: OMC_LABEL_UNUSED
18573 #line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18574  /* Pattern-matching assignment */
18575 #line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18576  tmpMeta[0] = _inElse;
18577 #line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18578  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
18579 #line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18580  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
18581 #line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18582  _e = tmpMeta[1];
18583 #line 2302 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18584  _algs = tmpMeta[2];
18585 #line 18585 OMC_FILE
18586 
18587 #line 2303 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18588  _e = omc_Absyn_traverseExpBidir(threadData, _e, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
18589 #line 18589 OMC_FILE
18590 
18591 #line 2304 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18592  _algs = omc_Absyn_traverseAlgorithmItemListBidir(threadData, _algs, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18593 #line 18593 OMC_FILE
18594 
18595 #line 2305 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18596  tmpMeta[0] = mmc_mk_box2(0, _e, _algs);
18597 #line 2305 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18598  _outElse = tmpMeta[0];
18599 #line 18599 OMC_FILE
18600  _return: OMC_LABEL_UNUSED
18601  if (out_arg) { *out_arg = _arg; }
18602  return _outElse;
18603 }
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmItemListBidir(threadData_t *threadData, modelica_metatype _inAlgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:19059
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseAlgorithmItem()

DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItem ( threadData_t threadData,
modelica_metatype  _inAlgorithmItem,
modelica_fnptr  _inFunc,
modelica_metatype  _inTypeA 
)

Definition at line 21133 of file Absyn.c.

21134 {
21135  modelica_metatype _outTpl = NULL;
21136  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
21137  MMC_SO();
21138  _tailrecursive: OMC_LABEL_UNUSED
21139 #line 21139 OMC_FILE
21140  { /* matchcontinue expression */
21141  volatile modelica_metatype tmp3_1;volatile modelica_fnptr tmp3_2;volatile modelica_metatype tmp3_3;
21142  tmp3_1 = _inAlgorithmItem;
21143  tmp3_2 = ((modelica_fnptr) _inFunc);
21144  tmp3_3 = _inTypeA;
21145  {
21146  modelica_fnptr _rel;
21147  modelica_metatype _arg = NULL;
21148  modelica_metatype _arg_1 = NULL;
21149  modelica_metatype _alg = NULL;
21150  modelica_metatype _alg_1 = NULL;
21151  modelica_metatype _oc = NULL;
21152  modelica_metatype _ai = NULL;
21153  modelica_metatype _info = NULL;
21154  volatile mmc_switch_type tmp3;
21155  int tmp4;
21156  tmp3 = 0;
21157  MMC_TRY_INTERNAL(mmc_jumper)
21158  tmp2_top:
21159  threadData->mmc_jumper = &new_mmc_jumper;
21160  for (; tmp3 < 2; tmp3++) {
21161  switch (MMC_SWITCH_CAST(tmp3)) {
21162  case 0: {
21163  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,3) == 0) goto tmp2_end;
21164  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
21165  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
21166  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
21167 
21168  _alg = tmpMeta[1];
21169  _oc = tmpMeta[2];
21170  _info = tmpMeta[3];
21171  _rel = tmp3_2;
21172  _arg = tmp3_3;
21173  /* Pattern matching succeeded */
21174 #line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21175  /* Pattern-matching assignment */
21176 #line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21177  tmpMeta[1] = omc_Absyn_traverseAlgorithm(threadData, _alg, ((modelica_fnptr) _rel), _arg);
21178 #line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21179  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21180 #line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21181  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21182 #line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21183  _alg_1 = tmpMeta[2];
21184 #line 1370 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21185  _arg_1 = tmpMeta[3];
21186 #line 21186 OMC_FILE
21187 #line 1371 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21188  tmpMeta[1] = mmc_mk_box4(3, &Absyn_AlgorithmItem_ALGORITHMITEM__desc, _alg_1, _oc, _info);
21189 #line 1371 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21190  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
21191 #line 1371 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21192  tmpMeta[0] = tmpMeta[2];
21193 #line 21193 OMC_FILE
21194  goto tmp2_done;
21195  }
21196  case 1: {
21197 
21198  _ai = tmp3_1;
21199  _arg = tmp3_3;
21200  /* Pattern matching succeeded */
21201 #line 1373 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21202  tmpMeta[1] = mmc_mk_box2(0, _ai, _arg);
21203 #line 1373 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21204  tmpMeta[0] = tmpMeta[1];
21205 #line 21205 OMC_FILE
21206  goto tmp2_done;
21207  }
21208  }
21209  goto tmp2_end;
21210  tmp2_end: ;
21211  }
21212  goto goto_1;
21213  tmp2_done:
21214  (void)tmp3;
21215  MMC_RESTORE_INTERNAL(mmc_jumper);
21216  goto tmp2_done2;
21217  goto_1:;
21218  MMC_CATCH_INTERNAL(mmc_jumper);
21219  if (++tmp3 < 2) {
21220  goto tmp2_top;
21221  }
21222  MMC_THROW_INTERNAL();
21223  tmp2_done2:;
21224  }
21225  }
21226  _outTpl = tmpMeta[0];
21227  _return: OMC_LABEL_UNUSED
21228  return _outTpl;
21229 }
DLLExport modelica_metatype omc_Absyn_traverseAlgorithm(threadData_t *threadData, modelica_metatype _inAlgorithm, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21232
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
float mmc_switch_type
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_AlgorithmItem_ALGORITHMITEM__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:

◆ omc_Absyn_traverseAlgorithmItemBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmItemBidir ( threadData_t threadData,
modelica_metatype  _inAlgorithmItem,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 18981 of file Absyn.c.

18982 {
18983  modelica_metatype _outAlgorithmItem = NULL;
18984  modelica_metatype _outArg = NULL;
18985  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
18986  MMC_SO();
18987  _tailrecursive: OMC_LABEL_UNUSED
18988 #line 2116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18989 
18990 #line 2116 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18991 
18992 #line 18992 OMC_FILE
18993  { /* match expression */
18994  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
18995  tmp4_1 = _inAlgorithmItem;
18996  tmp4_2 = _inArg;
18997  {
18998  modelica_metatype _arg = NULL;
18999  modelica_metatype _alg = NULL;
19000  modelica_metatype _cmt = NULL;
19001  modelica_metatype _info = NULL;
19002  volatile mmc_switch_type tmp4;
19003  int tmp5;
19004  tmp4 = 0;
19005  for (; tmp4 < 2; tmp4++) {
19006  switch (MMC_SWITCH_CAST(tmp4)) {
19007  case 0: {
19008  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,3) == 0) goto tmp3_end;
19009  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19010  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
19011  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
19012 
19013  _alg = tmpMeta[2];
19014  _cmt = tmpMeta[3];
19015  _info = tmpMeta[4];
19016  _arg = tmp4_2;
19017  /* Pattern matching succeeded */
19018 #line 2125 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19019  _alg = omc_Absyn_traverseAlgorithmBidir(threadData, _alg, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19020 #line 19020 OMC_FILE
19021 #line 2126 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19022  tmpMeta[2] = mmc_mk_box4(3, &Absyn_AlgorithmItem_ALGORITHMITEM__desc, _alg, _cmt, _info);
19023 #line 2126 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19024  tmpMeta[0+0] = tmpMeta[2];
19025 #line 2126 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19026  tmpMeta[0+1] = _arg;
19027 #line 19027 OMC_FILE
19028  goto tmp3_done;
19029  }
19030  case 1: {
19031  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
19032 
19033  /* Pattern matching succeeded */
19034 #line 2129 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19035  tmpMeta[0+0] = _inAlgorithmItem;
19036 #line 2129 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19037  tmpMeta[0+1] = _inArg;
19038 #line 19038 OMC_FILE
19039  goto tmp3_done;
19040  }
19041  }
19042  goto tmp3_end;
19043  tmp3_end: ;
19044  }
19045  goto goto_2;
19046  goto_2:;
19047  MMC_THROW_INTERNAL();
19048  goto tmp3_done;
19049  tmp3_done:;
19050  }
19051  }
19052  _outAlgorithmItem = tmpMeta[0+0];
19053  _outArg = tmpMeta[0+1];
19054  _return: OMC_LABEL_UNUSED
19055  if (out_outArg) { *out_outArg = _outArg; }
19056  return _outAlgorithmItem;
19057 }
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmBidir(threadData_t *threadData, modelica_metatype _inAlg, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:18244
float mmc_switch_type
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_AlgorithmItem_ALGORITHMITEM__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseAlgorithmItemList()

DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItemList ( threadData_t threadData,
modelica_metatype  _inAlgorithmItemList,
modelica_fnptr  _inFunc,
modelica_metatype  _inTypeA 
)

Definition at line 21030 of file Absyn.c.

21031 {
21032  modelica_metatype _outTpl = NULL;
21033  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
21034  MMC_SO();
21035  _tailrecursive: OMC_LABEL_UNUSED
21036 #line 21036 OMC_FILE
21037  { /* match expression */
21038  modelica_metatype tmp3_1;modelica_fnptr tmp3_2;modelica_metatype tmp3_3;
21039  tmp3_1 = _inAlgorithmItemList;
21040  tmp3_2 = ((modelica_fnptr) _inFunc);
21041  tmp3_3 = _inTypeA;
21042  {
21043  modelica_fnptr _rel;
21044  modelica_metatype _arg = NULL;
21045  modelica_metatype _arg_1 = NULL;
21046  modelica_metatype _arg_2 = NULL;
21047  modelica_metatype _ai = NULL;
21048  modelica_metatype _ai_1 = NULL;
21049  modelica_metatype _cdr = NULL;
21050  modelica_metatype _cdr_1 = NULL;
21051  volatile mmc_switch_type tmp3;
21052  int tmp4;
21053  tmp3 = 0;
21054  for (; tmp3 < 2; tmp3++) {
21055  switch (MMC_SWITCH_CAST(tmp3)) {
21056  case 0: {
21057  if (!listEmpty(tmp3_1)) goto tmp2_end;
21058 
21059  _arg = tmp3_3;
21060  /* Pattern matching succeeded */
21061 #line 1397 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21062  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
21063 #line 1397 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21064  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg);
21065 #line 1397 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21066  tmpMeta[0] = tmpMeta[2];
21067 #line 21067 OMC_FILE
21068  goto tmp2_done;
21069  }
21070  case 1: {
21071  if (listEmpty(tmp3_1)) goto tmp2_end;
21072  tmpMeta[1] = MMC_CAR(tmp3_1);
21073  tmpMeta[2] = MMC_CDR(tmp3_1);
21074 
21075  _ai = tmpMeta[1];
21076  _cdr = tmpMeta[2];
21077  _rel = tmp3_2;
21078  _arg = tmp3_3;
21079  /* Pattern matching succeeded */
21080 #line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21081  /* Pattern-matching assignment */
21082 #line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21083  tmpMeta[1] = omc_Absyn_traverseAlgorithmItem(threadData, _ai, ((modelica_fnptr) _rel), _arg);
21084 #line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21085  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21086 #line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21087  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21088 #line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21089  _ai_1 = tmpMeta[2];
21090 #line 1400 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21091  _arg_1 = tmpMeta[3];
21092 #line 21092 OMC_FILE
21093 
21094 #line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21095  /* Pattern-matching assignment */
21096 #line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21097  tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _cdr, ((modelica_fnptr) _rel), _arg_1);
21098 #line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21099  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21100 #line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21101  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21102 #line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21103  _cdr_1 = tmpMeta[2];
21104 #line 1401 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21105  _arg_2 = tmpMeta[3];
21106 #line 21106 OMC_FILE
21107 #line 1402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21108  tmpMeta[1] = mmc_mk_cons(_ai_1, _cdr_1);
21109 #line 1402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21110  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_2);
21111 #line 1402 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21112  tmpMeta[0] = tmpMeta[2];
21113 #line 21113 OMC_FILE
21114  goto tmp2_done;
21115  }
21116  }
21117  goto tmp2_end;
21118  tmp2_end: ;
21119  }
21120  goto goto_1;
21121  goto_1:;
21122  MMC_THROW_INTERNAL();
21123  goto tmp2_done;
21124  tmp2_done:;
21125  }
21126  }
21127  _outTpl = tmpMeta[0];
21128  _return: OMC_LABEL_UNUSED
21129  return _outTpl;
21130 }
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItem(threadData_t *threadData, modelica_metatype _inAlgorithmItem, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21133
void * modelica_fnptr
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItemList(threadData_t *threadData, modelica_metatype _inAlgorithmItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21030
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_traverseAlgorithmItemListBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseAlgorithmItemListBidir ( threadData_t threadData,
modelica_metatype  _inAlgs,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 19059 of file Absyn.c.

19060 {
19061  modelica_metatype _outAlgs = NULL;
19062  modelica_metatype _outArg = NULL;
19063  MMC_SO();
19064  _tailrecursive: OMC_LABEL_UNUSED
19065 #line 2096 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19066  _outAlgs = omc_List_map2FoldCheckReferenceEq(threadData, _inAlgs, boxvar_Absyn_traverseAlgorithmItemBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_outArg);
19067 #line 19067 OMC_FILE
19068  _return: OMC_LABEL_UNUSED
19069  if (out_outArg) { *out_outArg = _outArg; }
19070  return _outAlgs;
19071 }
void * modelica_fnptr
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseClassComponents()

DLLExport modelica_metatype omc_Absyn_traverseClassComponents ( threadData_t threadData,
modelica_metatype  _inClass,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 3037 of file Absyn.c.

3038 {
3039  modelica_metatype _outClass = NULL;
3040  modelica_metatype _outArg = NULL;
3041  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
3042  MMC_SO();
3043  _tailrecursive: OMC_LABEL_UNUSED
3044  _outClass = _inClass;
3045 #line 3045 OMC_FILE
3046  { /* match expression */
3047  modelica_metatype tmp3_1;
3048  tmp3_1 = _outClass;
3049  {
3050  modelica_metatype _body = NULL;
3051  volatile mmc_switch_type tmp3;
3052  int tmp4;
3053  tmp3 = 0;
3054  for (; tmp3 < 1; tmp3++) {
3055  switch (MMC_SWITCH_CAST(tmp3)) {
3056  case 0: {
3057 
3058  /* Pattern matching succeeded */
3059 #line 6278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3060  tmpMeta[1] = mmc_mk_box1(0, ((modelica_fnptr) _inFunc));
3061 #line 6278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3062  _body = omc_Absyn_traverseClassDef(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClass), 7))), (modelica_fnptr) mmc_mk_box2(0,closure2_Absyn_traverseClassPartComponents,tmpMeta[1]), _inArg ,&_outArg, NULL);
3063 #line 3063 OMC_FILE
3064 
3065 #line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3066  if((!referenceEq(_body, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClass), 7))))))
3067 #line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3068  {
3069 #line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3070  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(9));
3071 #line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3072  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outClass), 9*sizeof(modelica_metatype));
3073 #line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3074  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[7] = _body;
3075 #line 6280 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3076  _outClass = tmpMeta[1];
3077 #line 3077 OMC_FILE
3078  }
3079 #line 6281 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3080  tmpMeta[0] = _outClass;
3081 #line 3081 OMC_FILE
3082  goto tmp2_done;
3083  }
3084  }
3085  goto tmp2_end;
3086  tmp2_end: ;
3087  }
3088  goto goto_1;
3089  goto_1:;
3090  MMC_THROW_INTERNAL();
3091  goto tmp2_done;
3092  tmp2_done:;
3093  }
3094  }
3095  _outClass = tmpMeta[0];
3096  _return: OMC_LABEL_UNUSED
3097  if (out_outArg) { *out_outArg = _outArg; }
3098  return _outClass;
3099 }
float mmc_switch_type
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_fnptr
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassDef(threadData_t *threadData, modelica_metatype _inClassDef, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2401
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_traverseClassDef()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassDef ( threadData_t threadData,
modelica_metatype  _inClassDef,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_boolean out_outContinue 
)

Definition at line 2401 of file Absyn.c.

2402 {
2403  modelica_metatype _outClassDef = NULL;
2404  modelica_metatype _outArg = NULL;
2405  modelica_boolean _outContinue;
2406  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
2407  MMC_SO();
2408  _tailrecursive: OMC_LABEL_UNUSED
2409  _outClassDef = _inClassDef;
2410  _outArg = _inArg;
2411  _outContinue = 1;
2412 #line 2412 OMC_FILE
2413  { /* match expression */
2414  modelica_metatype tmp3_1;
2415  tmp3_1 = _outClassDef;
2416  {
2417  modelica_metatype _parts = NULL;
2418  int tmp3;
2419  {
2420  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
2421  case 3: {
2422 
2423  /* Pattern matching succeeded */
2424 #line 6488 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2425  _parts = omc_Absyn_traverseListGeneric(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClassDef), 4))), ((modelica_fnptr) _inFunc), _inArg ,&_outArg ,&_outContinue);
2426 #line 2426 OMC_FILE
2427 
2428 #line 6490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2429  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(7));
2430 #line 6490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2431  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outClassDef), 7*sizeof(modelica_metatype));
2432 #line 6490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2433  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = _parts;
2434 #line 6490 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2435  _outClassDef = tmpMeta[0];
2436 #line 2436 OMC_FILE
2437 #line 2437 OMC_FILE
2438  goto tmp2_done;
2439  }
2440  case 7: {
2441 
2442  /* Pattern matching succeeded */
2443 #line 6496 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2444  _parts = omc_Absyn_traverseListGeneric(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClassDef), 5))), ((modelica_fnptr) _inFunc), _inArg ,&_outArg ,&_outContinue);
2445 #line 2445 OMC_FILE
2446 
2447 #line 6498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2448  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(7));
2449 #line 6498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2450  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outClassDef), 7*sizeof(modelica_metatype));
2451 #line 6498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2452  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[5] = _parts;
2453 #line 6498 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2454  _outClassDef = tmpMeta[0];
2455 #line 2455 OMC_FILE
2456 #line 2456 OMC_FILE
2457  goto tmp2_done;
2458  }
2459  default:
2460  tmp2_default: OMC_LABEL_UNUSED; {
2461 
2462  /* Pattern matching succeeded */
2463 #line 2463 OMC_FILE
2464  goto tmp2_done;
2465  }
2466  }
2467  goto tmp2_end;
2468  tmp2_end: ;
2469  }
2470  goto goto_1;
2471  goto_1:;
2472  MMC_THROW_INTERNAL();
2473  goto tmp2_done;
2474  tmp2_done:;
2475  }
2476  }
2477  ;
2478  _return: OMC_LABEL_UNUSED
2479  if (out_outArg) { *out_outArg = _outArg; }
2480  if (out_outContinue) { *out_outContinue = _outContinue; }
2481  return _outClassDef;
2482 }
signed char modelica_boolean
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_fnptr
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseListGeneric(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2920
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseClassPartBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassPartBidir ( threadData_t threadData,
modelica_metatype  _cp,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 19087 of file Absyn.c.

19088 {
19089  modelica_metatype _outCp = NULL;
19090  modelica_metatype _outArg = NULL;
19091  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
19092  MMC_SO();
19093  _tailrecursive: OMC_LABEL_UNUSED
19094 #line 2043 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19095 
19096 #line 2043 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19097 
19098 #line 19098 OMC_FILE
19099  { /* match expression */
19100  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
19101  tmp4_1 = _cp;
19102  tmp4_2 = _inArg;
19103  {
19104  modelica_metatype _algs = NULL;
19105  modelica_metatype _eqs = NULL;
19106  modelica_metatype _arg = NULL;
19107  volatile mmc_switch_type tmp4;
19108  int tmp5;
19109  tmp4 = 0;
19110  for (; tmp4 < 2; tmp4++) {
19111  switch (MMC_SWITCH_CAST(tmp4)) {
19112  case 0: {
19113  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,1) == 0) goto tmp3_end;
19114  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19115 
19116  _algs = tmpMeta[2];
19117  _arg = tmp4_2;
19118  /* Pattern matching succeeded */
19119 #line 2050 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19120  _algs = omc_List_map2FoldCheckReferenceEq(threadData, _algs, boxvar_Absyn_traverseAlgorithmItemBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19121 #line 19121 OMC_FILE
19122 #line 2051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19123  tmpMeta[2] = mmc_mk_box2(8, &Absyn_ClassPart_ALGORITHMS__desc, _algs);
19124 #line 2051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19125  tmpMeta[0+0] = tmpMeta[2];
19126 #line 2051 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19127  tmpMeta[0+1] = _arg;
19128 #line 19128 OMC_FILE
19129  goto tmp3_done;
19130  }
19131  case 1: {
19132  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,1) == 0) goto tmp3_end;
19133  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19134 
19135  _eqs = tmpMeta[2];
19136  _arg = tmp4_2;
19137  /* Pattern matching succeeded */
19138 #line 2054 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19139  _eqs = omc_List_map2FoldCheckReferenceEq(threadData, _eqs, boxvar_Absyn_traverseEquationItemBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19140 #line 19140 OMC_FILE
19141 #line 2055 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19142  tmpMeta[2] = mmc_mk_box2(6, &Absyn_ClassPart_EQUATIONS__desc, _eqs);
19143 #line 2055 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19144  tmpMeta[0+0] = tmpMeta[2];
19145 #line 2055 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19146  tmpMeta[0+1] = _arg;
19147 #line 19147 OMC_FILE
19148  goto tmp3_done;
19149  }
19150  }
19151  goto tmp3_end;
19152  tmp3_end: ;
19153  }
19154  goto goto_2;
19155  goto_2:;
19156  MMC_THROW_INTERNAL();
19157  goto tmp3_done;
19158  tmp3_done:;
19159  }
19160  }
19161  _outCp = tmpMeta[0+0];
19162  _outArg = tmpMeta[0+1];
19163  _return: OMC_LABEL_UNUSED
19164  if (out_outArg) { *out_outArg = _outArg; }
19165  return _outCp;
19166 }
float mmc_switch_type
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassPart_ALGORITHMS__desc
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ClassPart_EQUATIONS__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseClassPartComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassPartComponents ( threadData_t threadData,
modelica_metatype  _inClassPart,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_boolean out_outContinue 
)

Definition at line 2823 of file Absyn.c.

2824 {
2825  modelica_metatype _outClassPart = NULL;
2826  modelica_metatype _outArg = NULL;
2827  modelica_boolean _outContinue;
2828  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
2829  MMC_SO();
2830  _tailrecursive: OMC_LABEL_UNUSED
2831  _outClassPart = _inClassPart;
2832  _outArg = _inArg;
2833  _outContinue = 1;
2834 #line 2834 OMC_FILE
2835  { /* match expression */
2836  modelica_metatype tmp3_1;
2837  tmp3_1 = _outClassPart;
2838  {
2839  modelica_metatype _items = NULL;
2840  int tmp3;
2841  {
2842  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
2843  case 3: {
2844 
2845  /* Pattern matching succeeded */
2846 #line 6345 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2847  tmpMeta[0] = mmc_mk_box1(0, ((modelica_fnptr) _inFunc));
2848 #line 6345 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2849  _items = omc_Absyn_traverseListGeneric(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClassPart), 2))), (modelica_fnptr) mmc_mk_box2(0,closure0_Absyn_traverseElementItemComponents,tmpMeta[0]), _inArg ,&_outArg ,&_outContinue);
2850 #line 2850 OMC_FILE
2851 
2852 #line 6348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2853  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
2854 #line 6348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2855  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outClassPart), 3*sizeof(modelica_metatype));
2856 #line 6348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2857  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = _items;
2858 #line 6348 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2859  _outClassPart = tmpMeta[0];
2860 #line 2860 OMC_FILE
2861 #line 2861 OMC_FILE
2862  goto tmp2_done;
2863  }
2864  case 4: {
2865 
2866  /* Pattern matching succeeded */
2867 #line 6354 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2868  tmpMeta[0] = mmc_mk_box1(0, ((modelica_fnptr) _inFunc));
2869 #line 6354 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2870  _items = omc_Absyn_traverseListGeneric(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outClassPart), 2))), (modelica_fnptr) mmc_mk_box2(0,closure1_Absyn_traverseElementItemComponents,tmpMeta[0]), _inArg ,&_outArg ,&_outContinue);
2871 #line 2871 OMC_FILE
2872 
2873 #line 6357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2874  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
2875 #line 6357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2876  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outClassPart), 3*sizeof(modelica_metatype));
2877 #line 6357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2878  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = _items;
2879 #line 6357 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2880  _outClassPart = tmpMeta[0];
2881 #line 2881 OMC_FILE
2882 #line 2882 OMC_FILE
2883  goto tmp2_done;
2884  }
2885  default:
2886  tmp2_default: OMC_LABEL_UNUSED; {
2887 
2888  /* Pattern matching succeeded */
2889 #line 2889 OMC_FILE
2890  goto tmp2_done;
2891  }
2892  }
2893  goto tmp2_end;
2894  tmp2_end: ;
2895  }
2896  goto goto_1;
2897  goto_1:;
2898  MMC_THROW_INTERNAL();
2899  goto tmp2_done;
2900  tmp2_done:;
2901  }
2902  }
2903  ;
2904  _return: OMC_LABEL_UNUSED
2905  if (out_outArg) { *out_outArg = _outArg; }
2906  if (out_outContinue) { *out_outContinue = _outContinue; }
2907  return _outClassPart;
2908 }
signed char modelica_boolean
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_fnptr
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseListGeneric(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2920
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_traverseElementComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementComponents ( threadData_t threadData,
modelica_metatype  _inElement,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_boolean out_outContinue 
)

Definition at line 2605 of file Absyn.c.

2606 {
2607  modelica_metatype _outElement = NULL;
2608  modelica_metatype _outArg = NULL;
2609  modelica_boolean _outContinue;
2610  modelica_boolean tmp1_c2 __attribute__((unused)) = 0;
2611  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
2612  MMC_SO();
2613  _tailrecursive: OMC_LABEL_UNUSED
2614  _outElement = _inElement;
2615 #line 6413 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2616 
2617 #line 6413 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2618 
2619 #line 6413 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2620 
2621 #line 2621 OMC_FILE
2622  { /* match expression */
2623  modelica_metatype tmp4_1;
2624  tmp4_1 = _outElement;
2625  {
2626  modelica_metatype _spec = NULL;
2627  volatile mmc_switch_type tmp4;
2628  int tmp5;
2629  tmp4 = 0;
2630  for (; tmp4 < 2; tmp4++) {
2631  switch (MMC_SWITCH_CAST(tmp4)) {
2632  case 0: {
2633  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,6) == 0) goto tmp3_end;
2634 
2635  /* Pattern matching succeeded */
2636 #line 6419 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2637  _spec = omc_Absyn_traverseElementSpecComponents(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outElement), 5))), ((modelica_fnptr) _inFunc), _inArg ,&_outArg ,&_outContinue);
2638 #line 2638 OMC_FILE
2639 
2640 #line 6422 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2641  if((!referenceEq(_spec, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outElement), 5))))))
2642 #line 6422 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2643  {
2644 #line 6423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2645  tmpMeta[3] = MMC_TAGPTR(mmc_alloc_words(8));
2646 #line 6423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2647  memcpy(MMC_UNTAGPTR(tmpMeta[3]), MMC_UNTAGPTR(_outElement), 8*sizeof(modelica_metatype));
2648 #line 6423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2649  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[3]))[5] = _spec;
2650 #line 6423 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2651  _outElement = tmpMeta[3];
2652 #line 2652 OMC_FILE
2653  }
2654 #line 6425 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2655  tmpMeta[0+0] = _outElement;
2656 #line 6425 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2657  tmpMeta[0+1] = _outArg;
2658 #line 6425 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2659  tmp1_c2 = _outContinue;
2660 #line 2660 OMC_FILE
2661  goto tmp3_done;
2662  }
2663  case 1: {
2664 
2665  /* Pattern matching succeeded */
2666 #line 6428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2667  tmpMeta[0+0] = _inElement;
2668 #line 6428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2669  tmpMeta[0+1] = _inArg;
2670 #line 6428 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2671  tmp1_c2 = 1;
2672 #line 2672 OMC_FILE
2673  goto tmp3_done;
2674  }
2675  }
2676  goto tmp3_end;
2677  tmp3_end: ;
2678  }
2679  goto goto_2;
2680  goto_2:;
2681  MMC_THROW_INTERNAL();
2682  goto tmp3_done;
2683  tmp3_done:;
2684  }
2685  }
2686  _outElement = tmpMeta[0+0];
2687  _outArg = tmpMeta[0+1];
2688  _outContinue = tmp1_c2;
2689  _return: OMC_LABEL_UNUSED
2690  if (out_outArg) { *out_outArg = _outArg; }
2691  if (out_outContinue) { *out_outContinue = _outContinue; }
2692  return _outElement;
2693 }
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementSpecComponents(threadData_t *threadData, modelica_metatype _inSpec, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2494
signed char modelica_boolean
float mmc_switch_type
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_fnptr
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseElementItemComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementItemComponents ( threadData_t threadData,
modelica_metatype  _inItem,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_boolean out_outContinue 
)

Definition at line 2705 of file Absyn.c.

2706 {
2707  modelica_metatype _outItem = NULL;
2708  modelica_metatype _outArg = NULL;
2709  modelica_boolean _outContinue;
2710  modelica_boolean tmp1_c2 __attribute__((unused)) = 0;
2711  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
2712  MMC_SO();
2713  _tailrecursive: OMC_LABEL_UNUSED
2714 #line 6381 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2715 
2716 #line 6381 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2717 
2718 #line 6381 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2719 
2720 #line 2720 OMC_FILE
2721  { /* match expression */
2722  modelica_metatype tmp4_1;
2723  tmp4_1 = _inItem;
2724  {
2725  modelica_metatype _elem = NULL;
2726  volatile mmc_switch_type tmp4;
2727  int tmp5;
2728  tmp4 = 0;
2729  for (; tmp4 < 2; tmp4++) {
2730  switch (MMC_SWITCH_CAST(tmp4)) {
2731  case 0: {
2732  modelica_boolean tmp6;
2733  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
2734 
2735  /* Pattern matching succeeded */
2736 #line 6387 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2737  _elem = omc_Absyn_traverseElementComponents(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inItem), 2))), ((modelica_fnptr) _inFunc), _inArg ,&_outArg ,&_outContinue);
2738 #line 2738 OMC_FILE
2739 
2740 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2741  tmp6 = (modelica_boolean)referenceEq(_elem, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inItem), 2))));
2742 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2743  if(tmp6)
2744 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2745  {
2746 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2747  tmpMeta[4] = _inItem;
2748 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2749  }
2750 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2751  else
2752 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2753  {
2754 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2755  tmpMeta[3] = mmc_mk_box2(3, &Absyn_ElementItem_ELEMENTITEM__desc, _elem);
2756 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2757  tmpMeta[4] = tmpMeta[3];
2758 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2759  }
2760 #line 6389 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2761  _outItem = tmpMeta[4];
2762 #line 2762 OMC_FILE
2763 #line 6390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2764  tmpMeta[0+0] = _outItem;
2765 #line 6390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2766  tmpMeta[0+1] = _outArg;
2767 #line 6390 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2768  tmp1_c2 = _outContinue;
2769 #line 2769 OMC_FILE
2770  goto tmp3_done;
2771  }
2772  case 1: {
2773 
2774  /* Pattern matching succeeded */
2775 #line 6393 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2776  tmpMeta[0+0] = _inItem;
2777 #line 6393 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2778  tmpMeta[0+1] = _inArg;
2779 #line 6393 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2780  tmp1_c2 = 1;
2781 #line 2781 OMC_FILE
2782  goto tmp3_done;
2783  }
2784  }
2785  goto tmp3_end;
2786  tmp3_end: ;
2787  }
2788  goto goto_2;
2789  goto_2:;
2790  MMC_THROW_INTERNAL();
2791  goto tmp3_done;
2792  tmp3_done:;
2793  }
2794  }
2795  _outItem = tmpMeta[0+0];
2796  _outArg = tmpMeta[0+1];
2797  _outContinue = tmp1_c2;
2798  _return: OMC_LABEL_UNUSED
2799  if (out_outArg) { *out_outArg = _outArg; }
2800  if (out_outContinue) { *out_outContinue = _outContinue; }
2801  return _outItem;
2802 }
signed char modelica_boolean
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementComponents(threadData_t *threadData, modelica_metatype _inElement, modelica_fnptr _inFunc, modelica_metatype _inArg, modelica_metatype *out_outArg, modelica_boolean *out_outContinue)
Definition: Absyn.c:2605
float mmc_switch_type
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ElementItem_ELEMENTITEM__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseElementSpecComponents()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseElementSpecComponents ( threadData_t threadData,
modelica_metatype  _inSpec,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_boolean out_outContinue 
)

Definition at line 2494 of file Absyn.c.

2495 {
2496  modelica_metatype _outSpec = NULL;
2497  modelica_metatype _outArg = NULL;
2498  modelica_boolean _outContinue;
2499  modelica_boolean tmp1_c2 __attribute__((unused)) = 0;
2500  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
2501  MMC_SO();
2502  _tailrecursive: OMC_LABEL_UNUSED
2503  _outSpec = _inSpec;
2504 #line 6448 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2505 
2506 #line 6448 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2507 
2508 #line 6448 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2509 
2510 #line 2510 OMC_FILE
2511  { /* match expression */
2512  modelica_metatype tmp4_1;
2513  tmp4_1 = _outSpec;
2514  {
2515  modelica_metatype _comps = NULL;
2516  volatile mmc_switch_type tmp4;
2517  int tmp5;
2518  tmp4 = 0;
2519  for (; tmp4 < 2; tmp4++) {
2520  switch (MMC_SWITCH_CAST(tmp4)) {
2521  case 0: {
2522  modelica_integer tmp6;
2523  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,3) == 0) goto tmp3_end;
2524 
2525  /* Pattern matching succeeded */
2526 #line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2527  /* Pattern-matching tuple assignment */
2528 #line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2529  tmpMeta[5] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outSpec), 4))), _inArg, &tmpMeta[3], &tmpMeta[4]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outSpec), 4))), _inArg, &tmpMeta[3], &tmpMeta[4]);
2530 #line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2531  _comps = tmpMeta[5];
2532 #line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2533  tmp6 = mmc_unbox_integer(tmpMeta[4]);
2534 #line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2535  _outArg = tmpMeta[3];
2536 #line 6455 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2537  _outContinue = tmp6 /* pattern as ty=Boolean */;
2538 #line 2538 OMC_FILE
2539 
2540 #line 6456 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2541  if((!referenceEq(_comps, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outSpec), 4))))))
2542 #line 6456 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2543  {
2544 #line 6457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2545  tmpMeta[3] = MMC_TAGPTR(mmc_alloc_words(5));
2546 #line 6457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2547  memcpy(MMC_UNTAGPTR(tmpMeta[3]), MMC_UNTAGPTR(_outSpec), 5*sizeof(modelica_metatype));
2548 #line 6457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2549  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[3]))[4] = _comps;
2550 #line 6457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2551  _outSpec = tmpMeta[3];
2552 #line 2552 OMC_FILE
2553  }
2554 #line 6459 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2555  tmpMeta[0+0] = _outSpec;
2556 #line 6459 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2557  tmpMeta[0+1] = _outArg;
2558 #line 6459 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2559  tmp1_c2 = _outContinue;
2560 #line 2560 OMC_FILE
2561  goto tmp3_done;
2562  }
2563  case 1: {
2564 
2565  /* Pattern matching succeeded */
2566 #line 6462 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2567  tmpMeta[0+0] = _inSpec;
2568 #line 6462 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2569  tmpMeta[0+1] = _inArg;
2570 #line 6462 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2571  tmp1_c2 = 1;
2572 #line 2572 OMC_FILE
2573  goto tmp3_done;
2574  }
2575  }
2576  goto tmp3_end;
2577  tmp3_end: ;
2578  }
2579  goto goto_2;
2580  goto_2:;
2581  MMC_THROW_INTERNAL();
2582  goto tmp3_done;
2583  tmp3_done:;
2584  }
2585  }
2586  _outSpec = tmpMeta[0+0];
2587  _outArg = tmpMeta[0+1];
2588  _outContinue = tmp1_c2;
2589  _return: OMC_LABEL_UNUSED
2590  if (out_outArg) { *out_outArg = _outArg; }
2591  if (out_outContinue) { *out_outContinue = _outContinue; }
2592  return _outSpec;
2593 }
m_integer modelica_integer
signed char modelica_boolean
float mmc_switch_type
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_traverseEquation()

DLLExport modelica_metatype omc_Absyn_traverseEquation ( threadData_t threadData,
modelica_metatype  _inEquation,
modelica_fnptr  _inFunc,
modelica_metatype  _inTypeA 
)

Definition at line 21959 of file Absyn.c.

21960 {
21961  modelica_metatype _outTpl = NULL;
21962  modelica_metatype tmpMeta[7] __attribute__((unused)) = {0};
21963  MMC_SO();
21964  _tailrecursive: OMC_LABEL_UNUSED
21965 #line 21965 OMC_FILE
21966  { /* matchcontinue expression */
21967  volatile modelica_metatype tmp3_1;volatile modelica_fnptr tmp3_2;volatile modelica_metatype tmp3_3;
21968  tmp3_1 = _inEquation;
21969  tmp3_2 = ((modelica_fnptr) _inFunc);
21970  tmp3_3 = _inTypeA;
21971  {
21972  modelica_metatype _arg = NULL;
21973  modelica_metatype _arg_1 = NULL;
21974  modelica_metatype _arg_2 = NULL;
21975  modelica_metatype _arg_3 = NULL;
21976  modelica_metatype _arg_4 = NULL;
21977  modelica_metatype _eq = NULL;
21978  modelica_metatype _eq_1 = NULL;
21979  modelica_fnptr _rel;
21980  modelica_metatype _e = NULL;
21981  modelica_metatype _e_1 = NULL;
21982  modelica_metatype _eqilst = NULL;
21983  modelica_metatype _eqilst1 = NULL;
21984  modelica_metatype _eqilst2 = NULL;
21985  modelica_metatype _eqilst_1 = NULL;
21986  modelica_metatype _eqilst1_1 = NULL;
21987  modelica_metatype _eqilst2_1 = NULL;
21988  modelica_metatype _eeqitlst = NULL;
21989  modelica_metatype _eeqitlst_1 = NULL;
21990  modelica_metatype _fis_1 = NULL;
21991  modelica_metatype _ei = NULL;
21992  modelica_metatype _ei_1 = NULL;
21993  volatile mmc_switch_type tmp3;
21994  int tmp4;
21995  tmp3 = 0;
21996  MMC_TRY_INTERNAL(mmc_jumper)
21997  tmp2_top:
21998  threadData->mmc_jumper = &new_mmc_jumper;
21999  for (; tmp3 < 5; tmp3++) {
22000  switch (MMC_SWITCH_CAST(tmp3)) {
22001  case 0: {
22002  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,4) == 0) goto tmp2_end;
22003  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
22004  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
22005  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
22006  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 5));
22007 
22008  _eq = tmp3_1;
22009  _e = tmpMeta[1];
22010  _eqilst1 = tmpMeta[2];
22011  _eeqitlst = tmpMeta[3];
22012  _eqilst2 = tmpMeta[4];
22013  _rel = tmp3_2;
22014  _arg = tmp3_3;
22015  tmp3 += 3; /* Pattern matching succeeded; we may skip some cases if we fail */
22016 #line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22017  /* Pattern-matching assignment */
22018 #line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22019  tmpMeta[1] = omc_Absyn_traverseEquationItemList(threadData, _eqilst1, ((modelica_fnptr) _rel), _arg);
22020 #line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22021  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
22022 #line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22023  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
22024 #line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22025  _eqilst1_1 = tmpMeta[2];
22026 #line 1163 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22027  _arg_1 = tmpMeta[3];
22028 #line 22028 OMC_FILE
22029 
22030 #line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22031  /* Pattern-matching assignment */
22032 #line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22033  tmpMeta[1] = omc_Absyn_traverseExpEqItemTupleList(threadData, _eeqitlst, ((modelica_fnptr) _rel), _arg_1);
22034 #line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22035  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
22036 #line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22037  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
22038 #line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22039  _eeqitlst_1 = tmpMeta[2];
22040 #line 1164 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22041  _arg_2 = tmpMeta[3];
22042 #line 22042 OMC_FILE
22043 
22044 #line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22045  /* Pattern-matching assignment */
22046 #line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22047  tmpMeta[1] = omc_Absyn_traverseEquationItemList(threadData, _eqilst2, ((modelica_fnptr) _rel), _arg_2);
22048 #line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22049  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
22050 #line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22051  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
22052 #line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22053  _eqilst2_1 = tmpMeta[2];
22054 #line 1165 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22055  _arg_3 = tmpMeta[3];
22056 #line 22056 OMC_FILE
22057 
22058 #line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22059  /* Pattern-matching assignment */
22060 #line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22061  tmpMeta[1] = mmc_mk_box2(0, _eq, _arg_3);
22062 #line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22063  tmpMeta[2] = mmc_mk_box2(0, _eq, _arg_3);
22064 #line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22065  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
22066 #line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22067  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
22068 #line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22069  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],0,4) == 0) goto goto_1;
22070 #line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22071  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
22072 #line 1166 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22073  _arg_4 = tmpMeta[5];
22074 #line 22074 OMC_FILE
22075 #line 1167 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22076  tmpMeta[1] = mmc_mk_box5(3, &Absyn_Equation_EQ__IF__desc, _e, _eqilst1_1, _eeqitlst_1, _eqilst2_1);
22077 #line 1167 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22078  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_4);
22079 #line 1167 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22080  tmpMeta[0] = tmpMeta[2];
22081 #line 22081 OMC_FILE
22082  goto tmp2_done;
22083  }
22084  case 1: {
22085  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,4,2) == 0) goto tmp2_end;
22086  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
22087 
22088  _eq = tmp3_1;
22089  _eqilst = tmpMeta[1];
22090  _rel = tmp3_2;
22091  _arg = tmp3_3;
22092  tmp3 += 2; /* Pattern matching succeeded; we may skip some cases if we fail */
22093 #line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22094  /* Pattern-matching assignment */
22095 #line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22096  tmpMeta[1] = omc_Absyn_traverseEquationItemList(threadData, _eqilst, ((modelica_fnptr) _rel), _arg);
22097 #line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22098  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
22099 #line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22100  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
22101 #line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22102  _eqilst_1 = tmpMeta[2];
22103 #line 1171 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22104  _arg_1 = tmpMeta[3];
22105 #line 22105 OMC_FILE
22106 
22107 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22108  /* Pattern-matching assignment */
22109 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22110  tmpMeta[1] = mmc_mk_box2(0, _eq, _arg_1);
22111 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22112  tmpMeta[2] = mmc_mk_box2(0, _eq, _arg_1);
22113 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22114  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
22115 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22116  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
22117 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22118  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],4,2) == 0) goto goto_1;
22119 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22120  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
22121 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22122  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
22123 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22124  _fis_1 = tmpMeta[5];
22125 #line 1172 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22126  _arg_2 = tmpMeta[6];
22127 #line 22127 OMC_FILE
22128 #line 1173 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22129  tmpMeta[1] = mmc_mk_box3(7, &Absyn_Equation_EQ__FOR__desc, _fis_1, _eqilst_1);
22130 #line 1173 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22131  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_2);
22132 #line 1173 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22133  tmpMeta[0] = tmpMeta[2];
22134 #line 22134 OMC_FILE
22135  goto tmp2_done;
22136  }
22137  case 2: {
22138  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,5,3) == 0) goto tmp2_end;
22139  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
22140  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
22141 
22142  _eq = tmp3_1;
22143  _eqilst = tmpMeta[1];
22144  _eeqitlst = tmpMeta[2];
22145  _rel = tmp3_2;
22146  _arg = tmp3_3;
22147  tmp3 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
22148 #line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22149  /* Pattern-matching assignment */
22150 #line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22151  tmpMeta[1] = omc_Absyn_traverseEquationItemList(threadData, _eqilst, ((modelica_fnptr) _rel), _arg);
22152 #line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22153  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
22154 #line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22155  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
22156 #line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22157  _eqilst_1 = tmpMeta[2];
22158 #line 1177 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22159  _arg_1 = tmpMeta[3];
22160 #line 22160 OMC_FILE
22161 
22162 #line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22163  /* Pattern-matching assignment */
22164 #line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22165  tmpMeta[1] = omc_Absyn_traverseExpEqItemTupleList(threadData, _eeqitlst, ((modelica_fnptr) _rel), _arg_1);
22166 #line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22167  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
22168 #line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22169  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
22170 #line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22171  _eeqitlst_1 = tmpMeta[2];
22172 #line 1178 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22173  _arg_2 = tmpMeta[3];
22174 #line 22174 OMC_FILE
22175 
22176 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22177  /* Pattern-matching assignment */
22178 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22179  tmpMeta[1] = mmc_mk_box2(0, _eq, _arg_2);
22180 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22181  tmpMeta[2] = mmc_mk_box2(0, _eq, _arg_2);
22182 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22183  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
22184 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22185  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
22186 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22187  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],5,3) == 0) goto goto_1;
22188 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22189  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[4]), 2));
22190 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22191  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
22192 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22193  _e_1 = tmpMeta[5];
22194 #line 1179 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22195  _arg_3 = tmpMeta[6];
22196 #line 22196 OMC_FILE
22197 #line 1180 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22198  tmpMeta[1] = mmc_mk_box4(8, &Absyn_Equation_EQ__WHEN__E__desc, _e_1, _eqilst_1, _eeqitlst_1);
22199 #line 1180 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22200  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_3);
22201 #line 1180 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22202  tmpMeta[0] = tmpMeta[2];
22203 #line 22203 OMC_FILE
22204  goto tmp2_done;
22205  }
22206  case 3: {
22207  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,7,1) == 0) goto tmp2_end;
22208  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
22209 
22210  _eq = tmp3_1;
22211  _ei = tmpMeta[1];
22212  _rel = tmp3_2;
22213  _arg = tmp3_3;
22214  /* Pattern matching succeeded */
22215 #line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22216  /* Pattern-matching assignment */
22217 #line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22218  tmpMeta[1] = omc_Absyn_traverseEquationItem(threadData, _ei, ((modelica_fnptr) _rel), _arg);
22219 #line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22220  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
22221 #line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22222  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
22223 #line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22224  _ei_1 = tmpMeta[2];
22225 #line 1184 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22226  _arg_1 = tmpMeta[3];
22227 #line 22227 OMC_FILE
22228 
22229 #line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22230  /* Pattern-matching assignment */
22231 #line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22232  tmpMeta[1] = mmc_mk_box2(0, _eq, _arg_1);
22233 #line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22234  tmpMeta[2] = mmc_mk_box2(0, _eq, _arg_1);
22235 #line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22236  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
22237 #line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22238  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
22239 #line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22240  if (mmc__uniontype__metarecord__typedef__equal(tmpMeta[4],7,1) == 0) goto goto_1;
22241 #line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22242  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
22243 #line 1185 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22244  _arg_2 = tmpMeta[5];
22245 #line 22245 OMC_FILE
22246 #line 1186 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22247  tmpMeta[1] = mmc_mk_box2(10, &Absyn_Equation_EQ__FAILURE__desc, _ei_1);
22248 #line 1186 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22249  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_2);
22250 #line 1186 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22251  tmpMeta[0] = tmpMeta[2];
22252 #line 22252 OMC_FILE
22253  goto tmp2_done;
22254  }
22255  case 4: {
22256 
22257  _eq = tmp3_1;
22258  _rel = tmp3_2;
22259  _arg = tmp3_3;
22260  /* Pattern matching succeeded */
22261 #line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22262  /* Pattern-matching assignment */
22263 #line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22264  tmpMeta[1] = mmc_mk_box2(0, _eq, _arg);
22265 #line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22266  tmpMeta[2] = mmc_mk_box2(0, _eq, _arg);
22267 #line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22268  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 2))), tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_rel), 1)))) (threadData, tmpMeta[1]);
22269 #line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22270  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
22271 #line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22272  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
22273 #line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22274  _eq_1 = tmpMeta[4];
22275 #line 1190 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22276  _arg_1 = tmpMeta[5];
22277 #line 22277 OMC_FILE
22278 #line 1191 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22279  tmpMeta[1] = mmc_mk_box2(0, _eq_1, _arg_1);
22280 #line 1191 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
22281  tmpMeta[0] = tmpMeta[1];
22282 #line 22282 OMC_FILE
22283  goto tmp2_done;
22284  }
22285  }
22286  goto tmp2_end;
22287  tmp2_end: ;
22288  }
22289  goto goto_1;
22290  tmp2_done:
22291  (void)tmp3;
22292  MMC_RESTORE_INTERNAL(mmc_jumper);
22293  goto tmp2_done2;
22294  goto_1:;
22295  MMC_CATCH_INTERNAL(mmc_jumper);
22296  if (++tmp3 < 5) {
22297  goto tmp2_top;
22298  }
22299  MMC_THROW_INTERNAL();
22300  tmp2_done2:;
22301  }
22302  }
22303  _outTpl = tmpMeta[0];
22304  _return: OMC_LABEL_UNUSED
22305  return _outTpl;
22306 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
DLLExport modelica_metatype omc_Absyn_traverseEquationItemList(threadData_t *threadData, modelica_metatype _inEquationItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21752
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__FOR__desc
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItem(threadData_t *threadData, modelica_metatype _inEquationItem, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21860
void * modelica_fnptr
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__IF__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__FAILURE__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__WHEN__E__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
DLLExport modelica_metatype omc_Absyn_traverseExpEqItemTupleList(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21638
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseEquationBidir()

DLLExport modelica_metatype omc_Absyn_traverseEquationBidir ( threadData_t threadData,
modelica_metatype  _inEquation,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 18647 of file Absyn.c.

18648 {
18649  modelica_metatype _outEquation = NULL;
18650  modelica_metatype _outArg = NULL;
18651  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
18652  MMC_SO();
18653  _tailrecursive: OMC_LABEL_UNUSED
18654 #line 2183 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18655 
18656 #line 2183 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18657 
18658 #line 18658 OMC_FILE
18659  { /* match expression */
18660  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
18661  tmp4_1 = _inEquation;
18662  tmp4_2 = _inArg;
18663  {
18664  modelica_metatype _arg = NULL;
18665  modelica_metatype _e1 = NULL;
18666  modelica_metatype _e2 = NULL;
18667  modelica_metatype _eqil1 = NULL;
18668  modelica_metatype _eqil2 = NULL;
18669  modelica_metatype _else_branch = NULL;
18670  modelica_metatype _cref1 = NULL;
18671  modelica_metatype _cref2 = NULL;
18672  modelica_metatype _iters = NULL;
18673  modelica_metatype _func_args = NULL;
18674  modelica_metatype _eq = NULL;
18675  int tmp4;
18676  {
18677  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
18678  case 3: {
18679  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,4) == 0) goto tmp3_end;
18680  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18681  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18682  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
18683  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
18684 
18685  _e1 = tmpMeta[2];
18686  _eqil1 = tmpMeta[3];
18687  _else_branch = tmpMeta[4];
18688  _eqil2 = tmpMeta[5];
18689  _arg = tmp4_2;
18690  /* Pattern matching succeeded */
18691 #line 2197 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18692  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18693 #line 18693 OMC_FILE
18694 
18695 #line 2198 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18696  _eqil1 = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18697 #line 18697 OMC_FILE
18698 
18699 #line 2199 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18700  _else_branch = omc_List_map2FoldCheckReferenceEq(threadData, _else_branch, boxvar_Absyn_traverseEquationBidirElse, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18701 #line 18701 OMC_FILE
18702 
18703 #line 2200 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18704  _eqil2 = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18705 #line 18705 OMC_FILE
18706 #line 2201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18707  tmpMeta[2] = mmc_mk_box5(3, &Absyn_Equation_EQ__IF__desc, _e1, _eqil1, _else_branch, _eqil2);
18708 #line 2201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18709  tmpMeta[0+0] = tmpMeta[2];
18710 #line 2201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18711  tmpMeta[0+1] = _arg;
18712 #line 18712 OMC_FILE
18713  goto tmp3_done;
18714  }
18715  case 4: {
18716  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,2) == 0) goto tmp3_end;
18717  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18718  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18719 
18720  _e1 = tmpMeta[2];
18721  _e2 = tmpMeta[3];
18722  _arg = tmp4_2;
18723  /* Pattern matching succeeded */
18724 #line 2206 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18725  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18726 #line 18726 OMC_FILE
18727 
18728 #line 2207 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18729  _e2 = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18730 #line 18730 OMC_FILE
18731 #line 2208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18732  tmpMeta[2] = mmc_mk_box3(4, &Absyn_Equation_EQ__EQUALS__desc, _e1, _e2);
18733 #line 2208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18734  tmpMeta[0+0] = tmpMeta[2];
18735 #line 2208 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18736  tmpMeta[0+1] = _arg;
18737 #line 18737 OMC_FILE
18738  goto tmp3_done;
18739  }
18740  case 5: {
18741  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,3) == 0) goto tmp3_end;
18742  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18743  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18744  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
18745 
18746  _e1 = tmpMeta[2];
18747  _e2 = tmpMeta[3];
18748  _cref1 = tmpMeta[4];
18749  _arg = tmp4_2;
18750  /* Pattern matching succeeded */
18751 #line 2212 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18752  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18753 #line 18753 OMC_FILE
18754 
18755 #line 2213 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18756  _e2 = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18757 #line 18757 OMC_FILE
18758 
18759 #line 2214 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18760  _cref1 = omc_Absyn_traverseExpBidirCref(threadData, _cref1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg, NULL);
18761 #line 18761 OMC_FILE
18762 #line 2215 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18763  tmpMeta[2] = mmc_mk_box4(5, &Absyn_Equation_EQ__PDE__desc, _e1, _e2, _cref1);
18764 #line 2215 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18765  tmpMeta[0+0] = tmpMeta[2];
18766 #line 2215 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18767  tmpMeta[0+1] = _arg;
18768 #line 18768 OMC_FILE
18769  goto tmp3_done;
18770  }
18771  case 6: {
18772  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,2) == 0) goto tmp3_end;
18773  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18774  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18775 
18776  _cref1 = tmpMeta[2];
18777  _cref2 = tmpMeta[3];
18778  _arg = tmp4_2;
18779  /* Pattern matching succeeded */
18780 #line 2220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18781  _cref1 = omc_Absyn_traverseExpBidirCref(threadData, _cref1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18782 #line 18782 OMC_FILE
18783 
18784 #line 2221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18785  _cref2 = omc_Absyn_traverseExpBidirCref(threadData, _cref2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18786 #line 18786 OMC_FILE
18787 #line 2222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18788  tmpMeta[2] = mmc_mk_box3(6, &Absyn_Equation_EQ__CONNECT__desc, _cref1, _cref2);
18789 #line 2222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18790  tmpMeta[0+0] = tmpMeta[2];
18791 #line 2222 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18792  tmpMeta[0+1] = _arg;
18793 #line 18793 OMC_FILE
18794  goto tmp3_done;
18795  }
18796  case 7: {
18797  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,2) == 0) goto tmp3_end;
18798  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18799  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18800 
18801  _iters = tmpMeta[2];
18802  _eqil1 = tmpMeta[3];
18803  _arg = tmp4_2;
18804  /* Pattern matching succeeded */
18805 #line 2227 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18806  _iters = omc_List_map2FoldCheckReferenceEq(threadData, _iters, boxvar_Absyn_traverseExpBidirIterator, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18807 #line 18807 OMC_FILE
18808 
18809 #line 2228 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18810  _eqil1 = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18811 #line 18811 OMC_FILE
18812 #line 2229 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18813  tmpMeta[2] = mmc_mk_box3(7, &Absyn_Equation_EQ__FOR__desc, _iters, _eqil1);
18814 #line 2229 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18815  tmpMeta[0+0] = tmpMeta[2];
18816 #line 2229 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18817  tmpMeta[0+1] = _arg;
18818 #line 18818 OMC_FILE
18819  goto tmp3_done;
18820  }
18821  case 8: {
18822  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,3) == 0) goto tmp3_end;
18823  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18824  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18825  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
18826 
18827  _e1 = tmpMeta[2];
18828  _eqil1 = tmpMeta[3];
18829  _else_branch = tmpMeta[4];
18830  _arg = tmp4_2;
18831  /* Pattern matching succeeded */
18832 #line 2234 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18833  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18834 #line 18834 OMC_FILE
18835 
18836 #line 2235 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18837  _eqil1 = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18838 #line 18838 OMC_FILE
18839 
18840 #line 2236 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18841  _else_branch = omc_List_map2FoldCheckReferenceEq(threadData, _else_branch, boxvar_Absyn_traverseEquationBidirElse, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18842 #line 18842 OMC_FILE
18843 #line 2237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18844  tmpMeta[2] = mmc_mk_box4(8, &Absyn_Equation_EQ__WHEN__E__desc, _e1, _eqil1, _else_branch);
18845 #line 2237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18846  tmpMeta[0+0] = tmpMeta[2];
18847 #line 2237 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18848  tmpMeta[0+1] = _arg;
18849 #line 18849 OMC_FILE
18850  goto tmp3_done;
18851  }
18852  case 9: {
18853  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
18854  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18855  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18856 
18857  _cref1 = tmpMeta[2];
18858  _func_args = tmpMeta[3];
18859  _arg = tmp4_2;
18860  /* Pattern matching succeeded */
18861 #line 2242 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18862  _cref1 = omc_Absyn_traverseExpBidirCref(threadData, _cref1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18863 #line 18863 OMC_FILE
18864 
18865 #line 2243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18866  _func_args = omc_Absyn_traverseExpBidirFunctionArgs(threadData, _func_args, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18867 #line 18867 OMC_FILE
18868 #line 2244 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18869  tmpMeta[2] = mmc_mk_box3(9, &Absyn_Equation_EQ__NORETCALL__desc, _cref1, _func_args);
18870 #line 2244 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18871  tmpMeta[0+0] = tmpMeta[2];
18872 #line 2244 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18873  tmpMeta[0+1] = _arg;
18874 #line 18874 OMC_FILE
18875  goto tmp3_done;
18876  }
18877  case 10: {
18878  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,1) == 0) goto tmp3_end;
18879  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18880 
18881  _eq = tmpMeta[2];
18882  _arg = tmp4_2;
18883  /* Pattern matching succeeded */
18884 #line 2249 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18885  _eq = omc_Absyn_traverseEquationItemBidir(threadData, _eq, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18886 #line 18886 OMC_FILE
18887 #line 2250 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18888  tmpMeta[2] = mmc_mk_box2(10, &Absyn_Equation_EQ__FAILURE__desc, _eq);
18889 #line 2250 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18890  tmpMeta[0+0] = tmpMeta[2];
18891 #line 2250 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18892  tmpMeta[0+1] = _arg;
18893 #line 18893 OMC_FILE
18894  goto tmp3_done;
18895  }
18896  }
18897  goto tmp3_end;
18898  tmp3_end: ;
18899  }
18900  goto goto_2;
18901  goto_2:;
18902  MMC_THROW_INTERNAL();
18903  goto tmp3_done;
18904  tmp3_done:;
18905  }
18906  }
18907  _outEquation = tmpMeta[0+0];
18908  _outArg = tmpMeta[0+1];
18909  _return: OMC_LABEL_UNUSED
18910  if (out_outArg) { *out_outArg = _outArg; }
18911  return _outEquation;
18912 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__CONNECT__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__NORETCALL__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__EQUALS__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__FOR__desc
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemBidir(threadData_t *threadData, modelica_metatype _inEquationItem, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:18914
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__PDE__desc
DLLExport modelica_metatype omc_Absyn_traverseExpBidirCref(threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:19702
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemListBidir(threadData_t *threadData, modelica_metatype _inEquationItems, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:19073
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__IF__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__FAILURE__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Equation_EQ__WHEN__E__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_traverseExpBidirFunctionArgs(threadData_t *threadData, modelica_metatype _inArgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:19426
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseEquationBidirElse()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationBidirElse ( threadData_t threadData,
modelica_metatype  _inElse,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_arg 
)

Definition at line 18605 of file Absyn.c.

18606 {
18607  modelica_metatype _outElse = NULL;
18608  modelica_metatype _arg = NULL;
18609  modelica_metatype _e = NULL;
18610  modelica_metatype _eqil = NULL;
18611  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
18612  MMC_SO();
18613  _tailrecursive: OMC_LABEL_UNUSED
18614 #line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18615  /* Pattern-matching assignment */
18616 #line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18617  tmpMeta[0] = _inElse;
18618 #line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18619  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
18620 #line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18621  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
18622 #line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18623  _e = tmpMeta[1];
18624 #line 2276 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18625  _eqil = tmpMeta[2];
18626 #line 18626 OMC_FILE
18627 
18628 #line 2277 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18629  _e = omc_Absyn_traverseExpBidir(threadData, _e, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
18630 #line 18630 OMC_FILE
18631 
18632 #line 2278 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18633  _eqil = omc_Absyn_traverseEquationItemListBidir(threadData, _eqil, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18634 #line 18634 OMC_FILE
18635 
18636 #line 2279 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18637  tmpMeta[0] = mmc_mk_box2(0, _e, _eqil);
18638 #line 2279 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18639  _outElse = tmpMeta[0];
18640 #line 18640 OMC_FILE
18641  _return: OMC_LABEL_UNUSED
18642  if (out_arg) { *out_arg = _arg; }
18643  return _outElse;
18644 }
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemListBidir(threadData_t *threadData, modelica_metatype _inEquationItems, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:19073
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseEquationItem()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItem ( threadData_t threadData,
modelica_metatype  _inEquationItem,
modelica_fnptr  _inFunc,
modelica_metatype  _inTypeA 
)

Definition at line 21860 of file Absyn.c.

21861 {
21862  modelica_metatype _outTpl = NULL;
21863  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
21864  MMC_SO();
21865  _tailrecursive: OMC_LABEL_UNUSED
21866 #line 21866 OMC_FILE
21867  { /* matchcontinue expression */
21868  volatile modelica_metatype tmp3_1;volatile modelica_fnptr tmp3_2;volatile modelica_metatype tmp3_3;
21869  tmp3_1 = _inEquationItem;
21870  tmp3_2 = ((modelica_fnptr) _inFunc);
21871  tmp3_3 = _inTypeA;
21872  {
21873  modelica_metatype _ei = NULL;
21874  modelica_fnptr _rel;
21875  modelica_metatype _arg = NULL;
21876  modelica_metatype _arg_1 = NULL;
21877  modelica_metatype _eq = NULL;
21878  modelica_metatype _eq_1 = NULL;
21879  modelica_metatype _oc = NULL;
21880  modelica_metatype _info = NULL;
21881  volatile mmc_switch_type tmp3;
21882  int tmp4;
21883  tmp3 = 0;
21884  MMC_TRY_INTERNAL(mmc_jumper)
21885  tmp2_top:
21886  threadData->mmc_jumper = &new_mmc_jumper;
21887  for (; tmp3 < 2; tmp3++) {
21888  switch (MMC_SWITCH_CAST(tmp3)) {
21889  case 0: {
21890  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,3) == 0) goto tmp2_end;
21891  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
21892  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
21893  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
21894 
21895  _eq = tmpMeta[1];
21896  _oc = tmpMeta[2];
21897  _info = tmpMeta[3];
21898  _rel = tmp3_2;
21899  _arg = tmp3_3;
21900  /* Pattern matching succeeded */
21901 #line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21902  /* Pattern-matching assignment */
21903 #line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21904  tmpMeta[1] = omc_Absyn_traverseEquation(threadData, _eq, ((modelica_fnptr) _rel), _arg);
21905 #line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21906  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
21907 #line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21908  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
21909 #line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21910  _eq_1 = tmpMeta[2];
21911 #line 1220 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21912  _arg_1 = tmpMeta[3];
21913 #line 21913 OMC_FILE
21914 #line 1221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21915  tmpMeta[1] = mmc_mk_box4(3, &Absyn_EquationItem_EQUATIONITEM__desc, _eq_1, _oc, _info);
21916 #line 1221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21917  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg_1);
21918 #line 1221 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21919  tmpMeta[0] = tmpMeta[2];
21920 #line 21920 OMC_FILE
21921  goto tmp2_done;
21922  }
21923  case 1: {
21924 
21925  _ei = tmp3_1;
21926  _arg = tmp3_3;
21927  /* Pattern matching succeeded */
21928 #line 1223 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21929  tmpMeta[1] = mmc_mk_box2(0, _ei, _arg);
21930 #line 1223 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21931  tmpMeta[0] = tmpMeta[1];
21932 #line 21932 OMC_FILE
21933  goto tmp2_done;
21934  }
21935  }
21936  goto tmp2_end;
21937  tmp2_end: ;
21938  }
21939  goto goto_1;
21940  tmp2_done:
21941  (void)tmp3;
21942  MMC_RESTORE_INTERNAL(mmc_jumper);
21943  goto tmp2_done2;
21944  goto_1:;
21945  MMC_CATCH_INTERNAL(mmc_jumper);
21946  if (++tmp3 < 2) {
21947  goto tmp2_top;
21948  }
21949  MMC_THROW_INTERNAL();
21950  tmp2_done2:;
21951  }
21952  }
21953  _outTpl = tmpMeta[0];
21954  _return: OMC_LABEL_UNUSED
21955  return _outTpl;
21956 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_EquationItem_EQUATIONITEM__desc
void * modelica_fnptr
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
DLLExport modelica_metatype omc_Absyn_traverseEquation(threadData_t *threadData, modelica_metatype _inEquation, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21959
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseEquationItemBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemBidir ( threadData_t threadData,
modelica_metatype  _inEquationItem,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 18914 of file Absyn.c.

18915 {
18916  modelica_metatype _outEquationItem = NULL;
18917  modelica_metatype _outArg = NULL;
18918  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
18919  MMC_SO();
18920  _tailrecursive: OMC_LABEL_UNUSED
18921 #line 2150 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18922 
18923 #line 2150 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18924 
18925 #line 18925 OMC_FILE
18926  { /* match expression */
18927  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
18928  tmp4_1 = _inEquationItem;
18929  tmp4_2 = _inArg;
18930  {
18931  modelica_metatype _arg = NULL;
18932  modelica_metatype _eq = NULL;
18933  modelica_metatype _cmt = NULL;
18934  modelica_metatype _info = NULL;
18935  volatile mmc_switch_type tmp4;
18936  int tmp5;
18937  tmp4 = 0;
18938  for (; tmp4 < 1; tmp4++) {
18939  switch (MMC_SWITCH_CAST(tmp4)) {
18940  case 0: {
18941  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,3) == 0) goto tmp3_end;
18942  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
18943  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
18944  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
18945 
18946  _eq = tmpMeta[2];
18947  _cmt = tmpMeta[3];
18948  _info = tmpMeta[4];
18949  _arg = tmp4_2;
18950  /* Pattern matching succeeded */
18951 #line 2159 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18952  _eq = omc_Absyn_traverseEquationBidir(threadData, _eq, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
18953 #line 18953 OMC_FILE
18954 #line 2160 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18955  tmpMeta[2] = mmc_mk_box4(3, &Absyn_EquationItem_EQUATIONITEM__desc, _eq, _cmt, _info);
18956 #line 2160 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18957  tmpMeta[0+0] = tmpMeta[2];
18958 #line 2160 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
18959  tmpMeta[0+1] = _arg;
18960 #line 18960 OMC_FILE
18961  goto tmp3_done;
18962  }
18963  }
18964  goto tmp3_end;
18965  tmp3_end: ;
18966  }
18967  goto goto_2;
18968  goto_2:;
18969  MMC_THROW_INTERNAL();
18970  goto tmp3_done;
18971  tmp3_done:;
18972  }
18973  }
18974  _outEquationItem = tmpMeta[0+0];
18975  _outArg = tmpMeta[0+1];
18976  _return: OMC_LABEL_UNUSED
18977  if (out_outArg) { *out_outArg = _outArg; }
18978  return _outEquationItem;
18979 }
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_EquationItem_EQUATIONITEM__desc
DLLExport modelica_metatype omc_Absyn_traverseEquationBidir(threadData_t *threadData, modelica_metatype _inEquation, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:18647
void * modelica_fnptr
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseEquationItemList()

DLLExport modelica_metatype omc_Absyn_traverseEquationItemList ( threadData_t threadData,
modelica_metatype  _inEquationItemList,
modelica_fnptr  _inFunc,
modelica_metatype  _inTypeA 
)

Definition at line 21752 of file Absyn.c.

21753 {
21754  modelica_metatype _outTpl = NULL;
21755  modelica_metatype _arg2 = NULL;
21756  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
21757  MMC_SO();
21758  _tailrecursive: OMC_LABEL_UNUSED
21759  _arg2 = _inTypeA;
21760 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21761  {
21762 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21763  modelica_metatype _$tmpVar19;
21764 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21765  modelica_metatype* tmp1;
21766 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21767  modelica_metatype _$tmpVar18;
21768 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21769  int tmp6;
21770 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21771  modelica_metatype el_loopVar = 0;
21772 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21773  modelica_metatype _el;
21774 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21775  el_loopVar = _inEquationItemList;
21776 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21777  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
21778 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21779  _$tmpVar19 = tmpMeta[1]; /* defaultValue */
21780 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21781  tmp1 = &_$tmpVar19;
21782 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21783  while(1) {
21784 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21785  tmp6 = 1;
21786 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21787  if (!listEmpty(el_loopVar)) {
21788 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21789  _el = MMC_CAR(el_loopVar);
21790 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21791  el_loopVar = MMC_CDR(el_loopVar);
21792 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21793  tmp6--;
21794 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21795  }
21796 #line 1243 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21797  if (tmp6 == 0) {
21798 #line 21798 OMC_FILE
21799  { /* match expression */
21800  modelica_metatype tmp4_1;
21801  tmp4_1 = _el;
21802  {
21803  modelica_metatype _ei = NULL;
21804  modelica_metatype _ei_1 = NULL;
21805  volatile mmc_switch_type tmp4;
21806  int tmp5;
21807  tmp4 = 0;
21808  for (; tmp4 < 1; tmp4++) {
21809  switch (MMC_SWITCH_CAST(tmp4)) {
21810  case 0: {
21811 
21812  _ei = tmp4_1;
21813  /* Pattern matching succeeded */
21814 #line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21815  /* Pattern-matching assignment */
21816 #line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21817  tmpMeta[3] = omc_Absyn_traverseEquationItem(threadData, _ei, ((modelica_fnptr) _inFunc), _arg2);
21818 #line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21819  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
21820 #line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21821  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
21822 #line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21823  _ei_1 = tmpMeta[4];
21824 #line 1247 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21825  _arg2 = tmpMeta[5];
21826 #line 21826 OMC_FILE
21827 #line 1248 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21828  tmpMeta[2] = _ei_1;
21829 #line 21829 OMC_FILE
21830  goto tmp3_done;
21831  }
21832  }
21833  goto tmp3_end;
21834  tmp3_end: ;
21835  }
21836  goto goto_2;
21837  goto_2:;
21838  MMC_THROW_INTERNAL();
21839  goto tmp3_done;
21840  tmp3_done:;
21841  }
21842  }_$tmpVar18 = tmpMeta[2];
21843  *tmp1 = mmc_mk_cons(_$tmpVar18,0);
21844  tmp1 = &MMC_CDR(*tmp1);
21845  } else if (tmp6 == 1) {
21846  break;
21847  } else {
21848  MMC_THROW_INTERNAL();
21849  }
21850  }
21851  *tmp1 = mmc_mk_nil();
21852  tmpMeta[0] = _$tmpVar19;
21853  }
21854  tmpMeta[3] = mmc_mk_box2(0, tmpMeta[0], _arg2);
21855  _outTpl = tmpMeta[3];
21856  _return: OMC_LABEL_UNUSED
21857  return _outTpl;
21858 }
float mmc_switch_type
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItem(threadData_t *threadData, modelica_metatype _inEquationItem, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21860
void * modelica_fnptr
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseEquationItemListBidir()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseEquationItemListBidir ( threadData_t threadData,
modelica_metatype  _inEquationItems,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 19073 of file Absyn.c.

19074 {
19075  modelica_metatype _outEquationItems = NULL;
19076  modelica_metatype _outArg = NULL;
19077  MMC_SO();
19078  _tailrecursive: OMC_LABEL_UNUSED
19079 #line 2076 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19080  _outEquationItems = omc_List_map2FoldCheckReferenceEq(threadData, _inEquationItems, boxvar_Absyn_traverseEquationItemBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_outArg);
19081 #line 19081 OMC_FILE
19082  _return: OMC_LABEL_UNUSED
19083  if (out_outArg) { *out_outArg = _outArg; }
19084  return _outEquationItems;
19085 }
void * modelica_fnptr
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExp()

DLLExport modelica_metatype omc_Absyn_traverseExp ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 20906 of file Absyn.c.

20907 {
20908  modelica_metatype _outExp = NULL;
20909  modelica_metatype _outArg = NULL;
20910  MMC_SO();
20911  _tailrecursive: OMC_LABEL_UNUSED
20912 #line 1457 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20913  _outExp = omc_Absyn_traverseExpBidir(threadData, _inExp, boxvar_Absyn_dummyTraverseExp, ((modelica_fnptr) _inFunc), _inArg ,&_outArg);
20914 #line 20914 OMC_FILE
20915  _return: OMC_LABEL_UNUSED
20916  if (out_outArg) { *out_outArg = _outArg; }
20917  return _outExp;
20918 }
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
void * modelica_metatype
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpAlgItemTupleList()

DLLExport modelica_metatype omc_Absyn_traverseExpAlgItemTupleList ( threadData_t threadData,
modelica_metatype  _inList,
modelica_fnptr  _inFunc,
modelica_metatype  _inTypeA 
)

Definition at line 20921 of file Absyn.c.

20922 {
20923  modelica_metatype _outTpl = NULL;
20924  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
20925  MMC_SO();
20926  _tailrecursive: OMC_LABEL_UNUSED
20927 #line 20927 OMC_FILE
20928  { /* match expression */
20929  modelica_metatype tmp3_1;modelica_fnptr tmp3_2;modelica_metatype tmp3_3;
20930  tmp3_1 = _inList;
20931  tmp3_2 = ((modelica_fnptr) _inFunc);
20932  tmp3_3 = _inTypeA;
20933  {
20934  modelica_fnptr _rel;
20935  modelica_metatype _arg = NULL;
20936  modelica_metatype _arg_1 = NULL;
20937  modelica_metatype _arg_2 = NULL;
20938  modelica_metatype _cdr = NULL;
20939  modelica_metatype _cdr_1 = NULL;
20940  modelica_metatype _e = NULL;
20941  modelica_metatype _ailst = NULL;
20942  modelica_metatype _ailst_1 = NULL;
20943  volatile mmc_switch_type tmp3;
20944  int tmp4;
20945  tmp3 = 0;
20946  for (; tmp3 < 2; tmp3++) {
20947  switch (MMC_SWITCH_CAST(tmp3)) {
20948  case 0: {
20949  if (!listEmpty(tmp3_1)) goto tmp2_end;
20950 
20951  _arg = tmp3_3;
20952  /* Pattern matching succeeded */
20953 #line 1429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20954  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
20955 #line 1429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20956  tmpMeta[2] = mmc_mk_box2(0, tmpMeta[1], _arg);
20957 #line 1429 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20958  tmpMeta[0] = tmpMeta[2];
20959 #line 20959 OMC_FILE
20960  goto tmp2_done;
20961  }
20962  case 1: {
20963  if (listEmpty(tmp3_1)) goto tmp2_end;
20964  tmpMeta[1] = MMC_CAR(tmp3_1);
20965  tmpMeta[2] = MMC_CDR(tmp3_1);
20966  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
20967  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
20968 
20969  _e = tmpMeta[3];
20970  _ailst = tmpMeta[4];
20971  _cdr = tmpMeta[2];
20972  _rel = tmp3_2;
20973  _arg = tmp3_3;
20974  /* Pattern matching succeeded */
20975 #line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20976  /* Pattern-matching assignment */
20977 #line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20978  tmpMeta[1] = omc_Absyn_traverseAlgorithmItemList(threadData, _ailst, ((modelica_fnptr) _rel), _arg);
20979 #line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20980  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
20981 #line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20982  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
20983 #line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20984  _ailst_1 = tmpMeta[2];
20985 #line 1432 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20986  _arg_1 = tmpMeta[3];
20987 #line 20987 OMC_FILE
20988 
20989 #line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20990  /* Pattern-matching assignment */
20991 #line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20992  tmpMeta[1] = omc_Absyn_traverseExpAlgItemTupleList(threadData, _cdr, ((modelica_fnptr) _rel), _arg_1);
20993 #line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20994  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
20995 #line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20996  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 2));
20997 #line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20998  _cdr_1 = tmpMeta[2];
20999 #line 1433 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21000  _arg_2 = tmpMeta[3];
21001 #line 21001 OMC_FILE
21002 #line 1434 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21003  tmpMeta[2] = mmc_mk_box2(0, _e, _ailst_1);
21004 #line 1434 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21005  tmpMeta[1] = mmc_mk_cons(tmpMeta[2], _cdr_1);
21006 #line 1434 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21007  tmpMeta[3] = mmc_mk_box2(0, tmpMeta[1], _arg_2);
21008 #line 1434 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21009  tmpMeta[0] = tmpMeta[3];
21010 #line 21010 OMC_FILE
21011  goto tmp2_done;
21012  }
21013  }
21014  goto tmp2_end;
21015  tmp2_end: ;
21016  }
21017  goto goto_1;
21018  goto_1:;
21019  MMC_THROW_INTERNAL();
21020  goto tmp2_done;
21021  tmp2_done:;
21022  }
21023  }
21024  _outTpl = tmpMeta[0];
21025  _return: OMC_LABEL_UNUSED
21026  return _outTpl;
21027 }
float mmc_switch_type
void * modelica_fnptr
DLLExport modelica_metatype omc_Absyn_traverseExpAlgItemTupleList(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:20921
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_traverseAlgorithmItemList(threadData_t *threadData, modelica_metatype _inAlgorithmItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21030
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpBidir()

DLLExport modelica_metatype omc_Absyn_traverseExpBidir ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_arg 
)

Definition at line 20838 of file Absyn.c.

20839 {
20840  modelica_metatype _e = NULL;
20841  modelica_metatype _arg = NULL;
20842  MMC_SO();
20843  _tailrecursive: OMC_LABEL_UNUSED
20844 #line 1544 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20845  _e = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_enterFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_enterFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_enterFunc), 2))), _inExp, _inArg ,&_arg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_enterFunc), 1)))) (threadData, _inExp, _inArg ,&_arg);
20846 #line 20846 OMC_FILE
20847 
20848 #line 1545 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20849  _e = omc_Absyn_traverseExpBidirSubExps(threadData, _e, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20850 #line 20850 OMC_FILE
20851 
20852 #line 1546 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20853  _e = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_exitFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_exitFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_exitFunc), 2))), _e, _arg ,&_arg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_exitFunc), 1)))) (threadData, _e, _arg ,&_arg);
20854 #line 20854 OMC_FILE
20855  _return: OMC_LABEL_UNUSED
20856  if (out_arg) { *out_arg = _arg; }
20857  return _e;
20858 }
void * modelica_fnptr
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpBidirSubExps(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:19870
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpBidirCref()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirCref ( threadData_t threadData,
modelica_metatype  _inCref,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_arg 
)

Definition at line 19702 of file Absyn.c.

19703 {
19704  modelica_metatype _outCref = NULL;
19705  modelica_metatype _arg = NULL;
19706  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
19707  MMC_SO();
19708  _tailrecursive: OMC_LABEL_UNUSED
19709 #line 1784 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19710 
19711 #line 1784 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19712 
19713 #line 19713 OMC_FILE
19714  { /* match expression */
19715  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
19716  tmp4_1 = _inCref;
19717  tmp4_2 = _inArg;
19718  {
19719  modelica_string _name = NULL;
19720  modelica_metatype _cr1 = NULL;
19721  modelica_metatype _cr2 = NULL;
19722  modelica_metatype _subs1 = NULL;
19723  modelica_metatype _subs2 = NULL;
19724  int tmp4;
19725  {
19726  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
19727  case 3: {
19728  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
19729  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19730 
19731  _cr1 = tmpMeta[2];
19732  _arg = tmp4_2;
19733  /* Pattern matching succeeded */
19734 #line 1793 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19735  _cr2 = omc_Absyn_traverseExpBidirCref(threadData, _cr1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19736 #line 19736 OMC_FILE
19737 #line 1794 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19738  tmpMeta[0+0] = (referenceEq(_cr1, _cr2)?_inCref:omc_Absyn_crefMakeFullyQualified(threadData, _cr2));
19739 #line 1794 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19740  tmpMeta[0+1] = _arg;
19741 #line 19741 OMC_FILE
19742  goto tmp3_done;
19743  }
19744  case 4: {
19745  modelica_boolean tmp5;
19746  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
19747  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19748  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
19749  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
19750 
19751  _name = tmpMeta[2];
19752  _subs1 = tmpMeta[3];
19753  _cr1 = tmpMeta[4];
19754  _arg = tmp4_2;
19755  /* Pattern matching succeeded */
19756 #line 1799 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19757  _subs2 = omc_List_map2FoldCheckReferenceEq(threadData, _subs1, boxvar_Absyn_traverseExpBidirSubs, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19758 #line 19758 OMC_FILE
19759 
19760 #line 1800 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19761  _cr2 = omc_Absyn_traverseExpBidirCref(threadData, _cr1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19762 #line 19762 OMC_FILE
19763 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19764  tmp5 = (modelica_boolean)(referenceEq(_cr1, _cr2) && referenceEq(_subs1, _subs2));
19765 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19766  if(tmp5)
19767 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19768  {
19769 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19770  tmpMeta[3] = _inCref;
19771 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19772  }
19773 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19774  else
19775 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19776  {
19777 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19778  tmpMeta[2] = mmc_mk_box4(4, &Absyn_ComponentRef_CREF__QUAL__desc, _name, _subs2, _cr2);
19779 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19780  tmpMeta[3] = tmpMeta[2];
19781 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19782  }
19783 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19784  tmpMeta[0+0] = tmpMeta[3];
19785 #line 1801 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19786  tmpMeta[0+1] = _arg;
19787 #line 19787 OMC_FILE
19788  goto tmp3_done;
19789  }
19790  case 5: {
19791  modelica_boolean tmp6;
19792  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,2) == 0) goto tmp3_end;
19793  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19794  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
19795 
19796  _name = tmpMeta[2];
19797  _subs1 = tmpMeta[3];
19798  _arg = tmp4_2;
19799  /* Pattern matching succeeded */
19800 #line 1806 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19801  _subs2 = omc_List_map2FoldCheckReferenceEq(threadData, _subs1, boxvar_Absyn_traverseExpBidirSubs, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19802 #line 19802 OMC_FILE
19803 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19804  tmp6 = (modelica_boolean)referenceEq(_subs1, _subs2);
19805 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19806  if(tmp6)
19807 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19808  {
19809 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19810  tmpMeta[3] = _inCref;
19811 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19812  }
19813 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19814  else
19815 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19816  {
19817 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19818  tmpMeta[2] = mmc_mk_box3(5, &Absyn_ComponentRef_CREF__IDENT__desc, _name, _subs2);
19819 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19820  tmpMeta[3] = tmpMeta[2];
19821 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19822  }
19823 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19824  tmpMeta[0+0] = tmpMeta[3];
19825 #line 1807 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19826  tmpMeta[0+1] = _arg;
19827 #line 19827 OMC_FILE
19828  goto tmp3_done;
19829  }
19830  case 7: {
19831  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,0) == 0) goto tmp3_end;
19832 
19833  /* Pattern matching succeeded */
19834 #line 1810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19835  tmpMeta[0+0] = _inCref;
19836 #line 1810 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19837  tmpMeta[0+1] = _inArg;
19838 #line 19838 OMC_FILE
19839  goto tmp3_done;
19840  }
19841  case 6: {
19842  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,0) == 0) goto tmp3_end;
19843 
19844  /* Pattern matching succeeded */
19845 #line 1811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19846  tmpMeta[0+0] = _inCref;
19847 #line 1811 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19848  tmpMeta[0+1] = _inArg;
19849 #line 19849 OMC_FILE
19850  goto tmp3_done;
19851  }
19852  }
19853  goto tmp3_end;
19854  tmp3_end: ;
19855  }
19856  goto goto_2;
19857  goto_2:;
19858  MMC_THROW_INTERNAL();
19859  goto tmp3_done;
19860  tmp3_done:;
19861  }
19862  }
19863  _outCref = tmpMeta[0+0];
19864  _arg = tmpMeta[0+1];
19865  _return: OMC_LABEL_UNUSED
19866  if (out_arg) { *out_arg = _arg; }
19867  return _outCref;
19868 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__IDENT__desc
modelica_metatype modelica_string
signed char modelica_boolean
DLLExport modelica_metatype omc_Absyn_crefMakeFullyQualified(threadData_t *threadData, modelica_metatype _inComponentRef)
Definition: Absyn.c:10549
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ComponentRef_CREF__QUAL__desc
DLLExport modelica_metatype omc_Absyn_traverseExpBidirCref(threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:19702
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpBidirElseIf()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirElseIf ( threadData_t threadData,
modelica_metatype  _inElseIf,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_arg 
)

Definition at line 19567 of file Absyn.c.

19568 {
19569  modelica_metatype _outElseIf = NULL;
19570  modelica_metatype _arg = NULL;
19571  modelica_metatype _e1 = NULL;
19572  modelica_metatype _e2 = NULL;
19573  modelica_metatype _tup = NULL;
19574  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
19575  MMC_SO();
19576  _tailrecursive: OMC_LABEL_UNUSED
19577 #line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19578  /* Pattern-matching assignment */
19579 #line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19580  tmpMeta[0] = _inElseIf;
19581 #line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19582  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 1));
19583 #line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19584  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
19585 #line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19586  _e1 = tmpMeta[1];
19587 #line 1872 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19588  _e2 = tmpMeta[2];
19589 #line 19589 OMC_FILE
19590 
19591 #line 1873 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19592  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
19593 #line 19593 OMC_FILE
19594 
19595 #line 1874 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19596  _e2 = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19597 #line 19597 OMC_FILE
19598 
19599 #line 1875 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19600  tmpMeta[0] = mmc_mk_box2(0, _e1, _e2);
19601 #line 1875 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19602  _outElseIf = tmpMeta[0];
19603 #line 19603 OMC_FILE
19604  _return: OMC_LABEL_UNUSED
19605  if (out_arg) { *out_arg = _arg; }
19606  return _outElseIf;
19607 }
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseExpBidirFunctionArgs()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirFunctionArgs ( threadData_t threadData,
modelica_metatype  _inArgs,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 19426 of file Absyn.c.

19427 {
19428  modelica_metatype _outArgs = NULL;
19429  modelica_metatype _outArg = NULL;
19430  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
19431  MMC_SO();
19432  _tailrecursive: OMC_LABEL_UNUSED
19433 #line 1897 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19434 
19435 #line 1897 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19436 
19437 #line 19437 OMC_FILE
19438  { /* match expression */
19439  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
19440  tmp4_1 = _inArgs;
19441  tmp4_2 = _inArg;
19442  {
19443  modelica_metatype _e1 = NULL;
19444  modelica_metatype _e2 = NULL;
19445  modelica_metatype _expl1 = NULL;
19446  modelica_metatype _expl2 = NULL;
19447  modelica_metatype _named_args1 = NULL;
19448  modelica_metatype _named_args2 = NULL;
19449  modelica_metatype _iters1 = NULL;
19450  modelica_metatype _iters2 = NULL;
19451  modelica_metatype _arg = NULL;
19452  modelica_metatype _iterType = NULL;
19453  volatile mmc_switch_type tmp4;
19454  int tmp5;
19455  tmp4 = 0;
19456  for (; tmp4 < 2; tmp4++) {
19457  switch (MMC_SWITCH_CAST(tmp4)) {
19458  case 0: {
19459  modelica_boolean tmp6;
19460  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
19461  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19462  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
19463 
19464  _expl1 = tmpMeta[2];
19465  _named_args1 = tmpMeta[3];
19466  _arg = tmp4_2;
19467  /* Pattern matching succeeded */
19468 #line 1908 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19469  _expl2 = omc_Absyn_traverseExpListBidir(threadData, _expl1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19470 #line 19470 OMC_FILE
19471 
19472 #line 1909 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19473  _named_args2 = omc_List_map2FoldCheckReferenceEq(threadData, _named_args1, boxvar_Absyn_traverseExpBidirNamedArg, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19474 #line 19474 OMC_FILE
19475 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19476  tmp6 = (modelica_boolean)(referenceEq(_expl1, _expl2) && referenceEq(_named_args1, _named_args2));
19477 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19478  if(tmp6)
19479 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19480  {
19481 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19482  tmpMeta[3] = _inArgs;
19483 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19484  }
19485 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19486  else
19487 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19488  {
19489 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19490  tmpMeta[2] = mmc_mk_box3(3, &Absyn_FunctionArgs_FUNCTIONARGS__desc, _expl2, _named_args2);
19491 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19492  tmpMeta[3] = tmpMeta[2];
19493 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19494  }
19495 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19496  tmpMeta[0+0] = tmpMeta[3];
19497 #line 1910 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19498  tmpMeta[0+1] = _arg;
19499 #line 19499 OMC_FILE
19500  goto tmp3_done;
19501  }
19502  case 1: {
19503  modelica_boolean tmp7;
19504  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
19505  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19506  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
19507  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
19508 
19509  _e1 = tmpMeta[2];
19510  _iterType = tmpMeta[3];
19511  _iters1 = tmpMeta[4];
19512  _arg = tmp4_2;
19513  /* Pattern matching succeeded */
19514 #line 1915 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19515  _e2 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19516 #line 19516 OMC_FILE
19517 
19518 #line 1916 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19519  _iters2 = omc_List_map2FoldCheckReferenceEq(threadData, _iters1, boxvar_Absyn_traverseExpBidirIterator, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19520 #line 19520 OMC_FILE
19521 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19522  tmp7 = (modelica_boolean)(referenceEq(_e1, _e2) && referenceEq(_iters1, _iters2));
19523 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19524  if(tmp7)
19525 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19526  {
19527 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19528  tmpMeta[3] = _inArgs;
19529 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19530  }
19531 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19532  else
19533 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19534  {
19535 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19536  tmpMeta[2] = mmc_mk_box4(4, &Absyn_FunctionArgs_FOR__ITER__FARG__desc, _e2, _iterType, _iters2);
19537 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19538  tmpMeta[3] = tmpMeta[2];
19539 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19540  }
19541 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19542  tmpMeta[0+0] = tmpMeta[3];
19543 #line 1917 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19544  tmpMeta[0+1] = _arg;
19545 #line 19545 OMC_FILE
19546  goto tmp3_done;
19547  }
19548  }
19549  goto tmp3_end;
19550  tmp3_end: ;
19551  }
19552  goto goto_2;
19553  goto_2:;
19554  MMC_THROW_INTERNAL();
19555  goto tmp3_done;
19556  tmp3_done:;
19557  }
19558  }
19559  _outArgs = tmpMeta[0+0];
19560  _outArg = tmpMeta[0+1];
19561  _return: OMC_LABEL_UNUSED
19562  if (out_outArg) { *out_outArg = _outArg; }
19563  return _outArgs;
19564 }
signed char modelica_boolean
float mmc_switch_type
ADD_METARECORD_DEFINITIONS struct record_description Absyn_FunctionArgs_FOR__ITER__FARG__desc
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_traverseExpListBidir(threadData_t *threadData, modelica_metatype _inExpl, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:20861
ADD_METARECORD_DEFINITIONS struct record_description Absyn_FunctionArgs_FUNCTIONARGS__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseExpBidirIterator()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirIterator ( threadData_t threadData,
modelica_metatype  _inIterator,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 19300 of file Absyn.c.

19301 {
19302  modelica_metatype _outIterator = NULL;
19303  modelica_metatype _outArg = NULL;
19304  modelica_string _name = NULL;
19305  modelica_metatype _guardExp1 = NULL;
19306  modelica_metatype _guardExp2 = NULL;
19307  modelica_metatype _range1 = NULL;
19308  modelica_metatype _range2 = NULL;
19309  modelica_boolean tmp1;
19310  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
19311  MMC_SO();
19312  _tailrecursive: OMC_LABEL_UNUSED
19313 #line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19314  /* Pattern-matching assignment */
19315 #line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19316  tmpMeta[0] = _inIterator;
19317 #line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19318  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
19319 #line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19320  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
19321 #line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19322  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
19323 #line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19324  _name = tmpMeta[1];
19325 #line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19326  _guardExp1 = tmpMeta[2];
19327 #line 1973 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19328  _range1 = tmpMeta[3];
19329 #line 19329 OMC_FILE
19330 
19331 #line 1974 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19332  _guardExp2 = omc_Absyn_traverseExpOptBidir(threadData, _guardExp1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_outArg);
19333 #line 19333 OMC_FILE
19334 
19335 #line 1975 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19336  _range2 = omc_Absyn_traverseExpOptBidir(threadData, _range1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _outArg ,&_outArg);
19337 #line 19337 OMC_FILE
19338 
19339 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19340  tmp1 = (modelica_boolean)(referenceEq(_guardExp1, _guardExp2) && referenceEq(_range1, _range2));
19341 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19342  if(tmp1)
19343 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19344  {
19345 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19346  tmpMeta[1] = _inIterator;
19347 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19348  }
19349 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19350  else
19351 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19352  {
19353 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19354  tmpMeta[0] = mmc_mk_box4(3, &Absyn_ForIterator_ITERATOR__desc, _name, _guardExp2, _range2);
19355 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19356  tmpMeta[1] = tmpMeta[0];
19357 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19358  }
19359 #line 1976 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19360  _outIterator = tmpMeta[1];
19361 #line 19361 OMC_FILE
19362  _return: OMC_LABEL_UNUSED
19363  if (out_outArg) { *out_outArg = _outArg; }
19364  return _outIterator;
19365 }
modelica_metatype modelica_string
signed char modelica_boolean
void * modelica_fnptr
DLLExport modelica_metatype omc_Absyn_traverseExpOptBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20771
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ForIterator_ITERATOR__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseExpBidirNamedArg()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirNamedArg ( threadData_t threadData,
modelica_metatype  _inArg,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inExtra,
modelica_metatype out_outExtra 
)

Definition at line 19368 of file Absyn.c.

19369 {
19370  modelica_metatype _outArg = NULL;
19371  modelica_metatype _outExtra = NULL;
19372  modelica_string _name = NULL;
19373  modelica_metatype _value1 = NULL;
19374  modelica_metatype _value2 = NULL;
19375  modelica_boolean tmp1;
19376  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
19377  MMC_SO();
19378  _tailrecursive: OMC_LABEL_UNUSED
19379 #line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19380  /* Pattern-matching assignment */
19381 #line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19382  tmpMeta[0] = _inArg;
19383 #line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19384  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
19385 #line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19386  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
19387 #line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19388  _name = tmpMeta[1];
19389 #line 1945 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19390  _value1 = tmpMeta[2];
19391 #line 19391 OMC_FILE
19392 
19393 #line 1946 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19394  _value2 = omc_Absyn_traverseExpBidir(threadData, _value1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inExtra ,&_outExtra);
19395 #line 19395 OMC_FILE
19396 
19397 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19398  tmp1 = (modelica_boolean)referenceEq(_value1, _value2);
19399 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19400  if(tmp1)
19401 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19402  {
19403 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19404  tmpMeta[1] = _inArg;
19405 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19406  }
19407 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19408  else
19409 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19410  {
19411 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19412  tmpMeta[0] = mmc_mk_box3(3, &Absyn_NamedArg_NAMEDARG__desc, _name, _value2);
19413 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19414  tmpMeta[1] = tmpMeta[0];
19415 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19416  }
19417 #line 1947 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19418  _outArg = tmpMeta[1];
19419 #line 19419 OMC_FILE
19420  _return: OMC_LABEL_UNUSED
19421  if (out_outExtra) { *out_outExtra = _outExtra; }
19422  return _outArg;
19423 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_NamedArg_NAMEDARG__desc
modelica_metatype modelica_string
signed char modelica_boolean
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseExpBidirSubExps()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpBidirSubExps ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_arg 
)

Definition at line 19870 of file Absyn.c.

19871 {
19872  modelica_metatype _e = NULL;
19873  modelica_metatype _arg = NULL;
19874  modelica_metatype tmpMeta[7] __attribute__((unused)) = {0};
19875  MMC_SO();
19876  _tailrecursive: OMC_LABEL_UNUSED
19877 #line 1603 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19878 
19879 #line 1603 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19880 
19881 #line 19881 OMC_FILE
19882  { /* match expression */
19883  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
19884  tmp4_1 = _inExp;
19885  tmp4_2 = _inArg;
19886  {
19887  modelica_metatype _e1 = NULL;
19888  modelica_metatype _e1m = NULL;
19889  modelica_metatype _e2 = NULL;
19890  modelica_metatype _e2m = NULL;
19891  modelica_metatype _e3 = NULL;
19892  modelica_metatype _e3m = NULL;
19893  modelica_metatype _oe1 = NULL;
19894  modelica_metatype _oe1m = NULL;
19895  modelica_metatype _op = NULL;
19896  modelica_metatype _cref = NULL;
19897  modelica_metatype _crefm = NULL;
19898  modelica_metatype _else_ifs1 = NULL;
19899  modelica_metatype _else_ifs2 = NULL;
19900  modelica_metatype _expl1 = NULL;
19901  modelica_metatype _expl2 = NULL;
19902  modelica_metatype _mat_expl = NULL;
19903  modelica_metatype _fargs1 = NULL;
19904  modelica_metatype _fargs2 = NULL;
19905  modelica_string _error_msg = NULL;
19906  modelica_string _id = NULL;
19907  modelica_string _enterName = NULL;
19908  modelica_string _exitName = NULL;
19909  modelica_metatype _match_ty = NULL;
19910  modelica_metatype _match_decls = NULL;
19911  modelica_metatype _match_cases = NULL;
19912  modelica_metatype _cmt = NULL;
19913  int tmp4;
19914  {
19915  switch (MMC_SWITCH_CAST(valueConstructor(tmp4_1))) {
19916  case 3: {
19917  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
19918 
19919  /* Pattern matching succeeded */
19920 #line 1621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19921  tmpMeta[0+0] = _inExp;
19922 #line 1621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19923  tmpMeta[0+1] = _inArg;
19924 #line 19924 OMC_FILE
19925  goto tmp3_done;
19926  }
19927  case 4: {
19928  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
19929 
19930  /* Pattern matching succeeded */
19931 #line 1622 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19932  tmpMeta[0+0] = _inExp;
19933 #line 1622 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19934  tmpMeta[0+1] = _inArg;
19935 #line 19935 OMC_FILE
19936  goto tmp3_done;
19937  }
19938  case 6: {
19939  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,3,1) == 0) goto tmp3_end;
19940 
19941  /* Pattern matching succeeded */
19942 #line 1623 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19943  tmpMeta[0+0] = _inExp;
19944 #line 1623 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19945  tmpMeta[0+1] = _inArg;
19946 #line 19946 OMC_FILE
19947  goto tmp3_done;
19948  }
19949  case 7: {
19950  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,4,1) == 0) goto tmp3_end;
19951 
19952  /* Pattern matching succeeded */
19953 #line 1624 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19954  tmpMeta[0+0] = _inExp;
19955 #line 1624 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19956  tmpMeta[0+1] = _inArg;
19957 #line 19957 OMC_FILE
19958  goto tmp3_done;
19959  }
19960  case 5: {
19961  modelica_boolean tmp5;
19962  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,2,1) == 0) goto tmp3_end;
19963  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19964 
19965  _cref = tmpMeta[2];
19966  _arg = tmp4_2;
19967  /* Pattern matching succeeded */
19968 #line 1628 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19969  _crefm = omc_Absyn_traverseExpBidirCref(threadData, _cref, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19970 #line 19970 OMC_FILE
19971 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19972  tmp5 = (modelica_boolean)referenceEq(_cref, _crefm);
19973 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19974  if(tmp5)
19975 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19976  {
19977 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19978  tmpMeta[3] = _inExp;
19979 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19980  }
19981 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19982  else
19983 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19984  {
19985 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19986  tmpMeta[2] = mmc_mk_box2(5, &Absyn_Exp_CREF__desc, _crefm);
19987 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19988  tmpMeta[3] = tmpMeta[2];
19989 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19990  }
19991 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19992  tmpMeta[0+0] = tmpMeta[3];
19993 #line 1629 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19994  tmpMeta[0+1] = _arg;
19995 #line 19995 OMC_FILE
19996  goto tmp3_done;
19997  }
19998  case 8: {
19999  modelica_boolean tmp6;
20000  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,5,3) == 0) goto tmp3_end;
20001  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20002  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20003  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
20004 
20005  _e1 = tmpMeta[2];
20006  _op = tmpMeta[3];
20007  _e2 = tmpMeta[4];
20008  _arg = tmp4_2;
20009  /* Pattern matching succeeded */
20010 #line 1634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20011  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20012 #line 20012 OMC_FILE
20013 
20014 #line 1635 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20015  _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20016 #line 20016 OMC_FILE
20017 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20018  tmp6 = (modelica_boolean)(referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m));
20019 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20020  if(tmp6)
20021 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20022  {
20023 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20024  tmpMeta[3] = _inExp;
20025 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20026  }
20027 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20028  else
20029 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20030  {
20031 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20032  tmpMeta[2] = mmc_mk_box4(8, &Absyn_Exp_BINARY__desc, _e1m, _op, _e2m);
20033 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20034  tmpMeta[3] = tmpMeta[2];
20035 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20036  }
20037 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20038  tmpMeta[0+0] = tmpMeta[3];
20039 #line 1636 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20040  tmpMeta[0+1] = _arg;
20041 #line 20041 OMC_FILE
20042  goto tmp3_done;
20043  }
20044  case 9: {
20045  modelica_boolean tmp7;
20046  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,6,2) == 0) goto tmp3_end;
20047  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20048  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20049 
20050  _op = tmpMeta[2];
20051  _e1 = tmpMeta[3];
20052  _arg = tmp4_2;
20053  /* Pattern matching succeeded */
20054 #line 1641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20055  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20056 #line 20056 OMC_FILE
20057 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20058  tmp7 = (modelica_boolean)referenceEq(_e1, _e1m);
20059 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20060  if(tmp7)
20061 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20062  {
20063 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20064  tmpMeta[3] = _inExp;
20065 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20066  }
20067 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20068  else
20069 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20070  {
20071 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20072  tmpMeta[2] = mmc_mk_box3(9, &Absyn_Exp_UNARY__desc, _op, _e1m);
20073 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20074  tmpMeta[3] = tmpMeta[2];
20075 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20076  }
20077 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20078  tmpMeta[0+0] = tmpMeta[3];
20079 #line 1642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20080  tmpMeta[0+1] = _arg;
20081 #line 20081 OMC_FILE
20082  goto tmp3_done;
20083  }
20084  case 10: {
20085  modelica_boolean tmp8;
20086  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,7,3) == 0) goto tmp3_end;
20087  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20088  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20089  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
20090 
20091  _e1 = tmpMeta[2];
20092  _op = tmpMeta[3];
20093  _e2 = tmpMeta[4];
20094  _arg = tmp4_2;
20095  /* Pattern matching succeeded */
20096 #line 1647 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20097  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20098 #line 20098 OMC_FILE
20099 
20100 #line 1648 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20101  _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20102 #line 20102 OMC_FILE
20103 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20104  tmp8 = (modelica_boolean)(referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m));
20105 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20106  if(tmp8)
20107 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20108  {
20109 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20110  tmpMeta[3] = _inExp;
20111 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20112  }
20113 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20114  else
20115 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20116  {
20117 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20118  tmpMeta[2] = mmc_mk_box4(10, &Absyn_Exp_LBINARY__desc, _e1m, _op, _e2m);
20119 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20120  tmpMeta[3] = tmpMeta[2];
20121 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20122  }
20123 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20124  tmpMeta[0+0] = tmpMeta[3];
20125 #line 1649 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20126  tmpMeta[0+1] = _arg;
20127 #line 20127 OMC_FILE
20128  goto tmp3_done;
20129  }
20130  case 11: {
20131  modelica_boolean tmp9;
20132  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,8,2) == 0) goto tmp3_end;
20133  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20134  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20135 
20136  _op = tmpMeta[2];
20137  _e1 = tmpMeta[3];
20138  _arg = tmp4_2;
20139  /* Pattern matching succeeded */
20140 #line 1654 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20141  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20142 #line 20142 OMC_FILE
20143 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20144  tmp9 = (modelica_boolean)referenceEq(_e1, _e1m);
20145 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20146  if(tmp9)
20147 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20148  {
20149 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20150  tmpMeta[3] = _inExp;
20151 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20152  }
20153 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20154  else
20155 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20156  {
20157 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20158  tmpMeta[2] = mmc_mk_box3(11, &Absyn_Exp_LUNARY__desc, _op, _e1m);
20159 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20160  tmpMeta[3] = tmpMeta[2];
20161 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20162  }
20163 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20164  tmpMeta[0+0] = tmpMeta[3];
20165 #line 1655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20166  tmpMeta[0+1] = _arg;
20167 #line 20167 OMC_FILE
20168  goto tmp3_done;
20169  }
20170  case 12: {
20171  modelica_boolean tmp10;
20172  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,9,3) == 0) goto tmp3_end;
20173  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20174  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20175  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
20176 
20177  _e1 = tmpMeta[2];
20178  _op = tmpMeta[3];
20179  _e2 = tmpMeta[4];
20180  _arg = tmp4_2;
20181  /* Pattern matching succeeded */
20182 #line 1660 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20183  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20184 #line 20184 OMC_FILE
20185 
20186 #line 1661 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20187  _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20188 #line 20188 OMC_FILE
20189 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20190  tmp10 = (modelica_boolean)(referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m));
20191 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20192  if(tmp10)
20193 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20194  {
20195 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20196  tmpMeta[3] = _inExp;
20197 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20198  }
20199 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20200  else
20201 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20202  {
20203 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20204  tmpMeta[2] = mmc_mk_box4(12, &Absyn_Exp_RELATION__desc, _e1m, _op, _e2m);
20205 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20206  tmpMeta[3] = tmpMeta[2];
20207 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20208  }
20209 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20210  tmpMeta[0+0] = tmpMeta[3];
20211 #line 1662 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20212  tmpMeta[0+1] = _arg;
20213 #line 20213 OMC_FILE
20214  goto tmp3_done;
20215  }
20216  case 13: {
20217  modelica_boolean tmp11;
20218  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,10,4) == 0) goto tmp3_end;
20219  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20220  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20221  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
20222  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
20223 
20224  _e1 = tmpMeta[2];
20225  _e2 = tmpMeta[3];
20226  _e3 = tmpMeta[4];
20227  _else_ifs1 = tmpMeta[5];
20228  _arg = tmp4_2;
20229  /* Pattern matching succeeded */
20230 #line 1668 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20231  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20232 #line 20232 OMC_FILE
20233 
20234 #line 1669 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20235  _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20236 #line 20236 OMC_FILE
20237 
20238 #line 1670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20239  _e3m = omc_Absyn_traverseExpBidir(threadData, _e3, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20240 #line 20240 OMC_FILE
20241 
20242 #line 1671 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20243  _else_ifs2 = omc_List_map2FoldCheckReferenceEq(threadData, _else_ifs1, boxvar_Absyn_traverseExpBidirElseIf, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20244 #line 20244 OMC_FILE
20245 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20246  tmp11 = (modelica_boolean)(((referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m)) && referenceEq(_e3, _e3m)) && referenceEq(_else_ifs1, _else_ifs2));
20247 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20248  if(tmp11)
20249 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20250  {
20251 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20252  tmpMeta[3] = _inExp;
20253 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20254  }
20255 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20256  else
20257 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20258  {
20259 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20260  tmpMeta[2] = mmc_mk_box5(13, &Absyn_Exp_IFEXP__desc, _e1m, _e2m, _e3m, _else_ifs2);
20261 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20262  tmpMeta[3] = tmpMeta[2];
20263 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20264  }
20265 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20266  tmpMeta[0+0] = tmpMeta[3];
20267 #line 1672 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20268  tmpMeta[0+1] = _arg;
20269 #line 20269 OMC_FILE
20270  goto tmp3_done;
20271  }
20272  case 14: {
20273  modelica_boolean tmp12;
20274  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,11,2) == 0) goto tmp3_end;
20275  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20276  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20277 
20278  _cref = tmpMeta[2];
20279  _fargs1 = tmpMeta[3];
20280  _arg = tmp4_2;
20281  /* Pattern matching succeeded */
20282 #line 1677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20283  _fargs2 = omc_Absyn_traverseExpBidirFunctionArgs(threadData, _fargs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20284 #line 20284 OMC_FILE
20285 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20286  tmp12 = (modelica_boolean)referenceEq(_fargs1, _fargs2);
20287 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20288  if(tmp12)
20289 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20290  {
20291 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20292  tmpMeta[3] = _inExp;
20293 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20294  }
20295 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20296  else
20297 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20298  {
20299 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20300  tmpMeta[2] = mmc_mk_box3(14, &Absyn_Exp_CALL__desc, _cref, _fargs2);
20301 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20302  tmpMeta[3] = tmpMeta[2];
20303 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20304  }
20305 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20306  tmpMeta[0+0] = tmpMeta[3];
20307 #line 1678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20308  tmpMeta[0+1] = _arg;
20309 #line 20309 OMC_FILE
20310  goto tmp3_done;
20311  }
20312  case 15: {
20313  modelica_boolean tmp13;
20314  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,12,2) == 0) goto tmp3_end;
20315  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20316  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20317 
20318  _cref = tmpMeta[2];
20319  _fargs1 = tmpMeta[3];
20320  _arg = tmp4_2;
20321  /* Pattern matching succeeded */
20322 #line 1683 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20323  _fargs2 = omc_Absyn_traverseExpBidirFunctionArgs(threadData, _fargs1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20324 #line 20324 OMC_FILE
20325 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20326  tmp13 = (modelica_boolean)referenceEq(_fargs1, _fargs2);
20327 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20328  if(tmp13)
20329 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20330  {
20331 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20332  tmpMeta[3] = _inExp;
20333 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20334  }
20335 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20336  else
20337 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20338  {
20339 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20340  tmpMeta[2] = mmc_mk_box3(15, &Absyn_Exp_PARTEVALFUNCTION__desc, _cref, _fargs2);
20341 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20342  tmpMeta[3] = tmpMeta[2];
20343 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20344  }
20345 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20346  tmpMeta[0+0] = tmpMeta[3];
20347 #line 1684 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20348  tmpMeta[0+1] = _arg;
20349 #line 20349 OMC_FILE
20350  goto tmp3_done;
20351  }
20352  case 16: {
20353  modelica_boolean tmp14;
20354  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,13,1) == 0) goto tmp3_end;
20355  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20356 
20357  _expl1 = tmpMeta[2];
20358  _arg = tmp4_2;
20359  /* Pattern matching succeeded */
20360 #line 1689 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20361  _expl2 = omc_Absyn_traverseExpListBidir(threadData, _expl1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20362 #line 20362 OMC_FILE
20363 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20364  tmp14 = (modelica_boolean)referenceEq(_expl1, _expl2);
20365 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20366  if(tmp14)
20367 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20368  {
20369 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20370  tmpMeta[3] = _inExp;
20371 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20372  }
20373 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20374  else
20375 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20376  {
20377 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20378  tmpMeta[2] = mmc_mk_box2(16, &Absyn_Exp_ARRAY__desc, _expl2);
20379 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20380  tmpMeta[3] = tmpMeta[2];
20381 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20382  }
20383 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20384  tmpMeta[0+0] = tmpMeta[3];
20385 #line 1690 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20386  tmpMeta[0+1] = _arg;
20387 #line 20387 OMC_FILE
20388  goto tmp3_done;
20389  }
20390  case 17: {
20391  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,14,1) == 0) goto tmp3_end;
20392  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20393 
20394  _mat_expl = tmpMeta[2];
20395  _arg = tmp4_2;
20396  /* Pattern matching succeeded */
20397 #line 1695 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20398  _mat_expl = omc_List_map2FoldCheckReferenceEq(threadData, _mat_expl, boxvar_Absyn_traverseExpListBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20399 #line 20399 OMC_FILE
20400 #line 1696 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20401  tmpMeta[2] = mmc_mk_box2(17, &Absyn_Exp_MATRIX__desc, _mat_expl);
20402 #line 1696 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20403  tmpMeta[0+0] = tmpMeta[2];
20404 #line 1696 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20405  tmpMeta[0+1] = _arg;
20406 #line 20406 OMC_FILE
20407  goto tmp3_done;
20408  }
20409  case 18: {
20410  modelica_boolean tmp15;
20411  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,15,3) == 0) goto tmp3_end;
20412  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20413  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20414  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
20415 
20416  _e1 = tmpMeta[2];
20417  _oe1 = tmpMeta[3];
20418  _e2 = tmpMeta[4];
20419  _arg = tmp4_2;
20420  /* Pattern matching succeeded */
20421 #line 1701 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20422  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20423 #line 20423 OMC_FILE
20424 
20425 #line 1702 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20426  _oe1m = omc_Absyn_traverseExpOptBidir(threadData, _oe1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20427 #line 20427 OMC_FILE
20428 
20429 #line 1703 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20430  _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20431 #line 20431 OMC_FILE
20432 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20433  tmp15 = (modelica_boolean)((referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m)) && referenceEq(_oe1, _oe1m));
20434 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20435  if(tmp15)
20436 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20437  {
20438 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20439  tmpMeta[3] = _inExp;
20440 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20441  }
20442 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20443  else
20444 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20445  {
20446 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20447  tmpMeta[2] = mmc_mk_box4(18, &Absyn_Exp_RANGE__desc, _e1m, _oe1m, _e2m);
20448 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20449  tmpMeta[3] = tmpMeta[2];
20450 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20451  }
20452 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20453  tmpMeta[0+0] = tmpMeta[3];
20454 #line 1704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20455  tmpMeta[0+1] = _arg;
20456 #line 20456 OMC_FILE
20457  goto tmp3_done;
20458  }
20459  case 20: {
20460  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,17,0) == 0) goto tmp3_end;
20461 
20462  /* Pattern matching succeeded */
20463 #line 1707 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20464  tmpMeta[0+0] = _inExp;
20465 #line 1707 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20466  tmpMeta[0+1] = _inArg;
20467 #line 20467 OMC_FILE
20468  goto tmp3_done;
20469  }
20470  case 19: {
20471  modelica_boolean tmp16;
20472  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,16,1) == 0) goto tmp3_end;
20473  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20474 
20475  _expl1 = tmpMeta[2];
20476  _arg = tmp4_2;
20477  /* Pattern matching succeeded */
20478 #line 1711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20479  _expl2 = omc_Absyn_traverseExpListBidir(threadData, _expl1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20480 #line 20480 OMC_FILE
20481 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20482  tmp16 = (modelica_boolean)referenceEq(_expl1, _expl2);
20483 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20484  if(tmp16)
20485 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20486  {
20487 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20488  tmpMeta[3] = _inExp;
20489 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20490  }
20491 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20492  else
20493 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20494  {
20495 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20496  tmpMeta[2] = mmc_mk_box2(19, &Absyn_Exp_TUPLE__desc, _expl2);
20497 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20498  tmpMeta[3] = tmpMeta[2];
20499 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20500  }
20501 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20502  tmpMeta[0+0] = tmpMeta[3];
20503 #line 1712 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20504  tmpMeta[0+1] = _arg;
20505 #line 20505 OMC_FILE
20506  goto tmp3_done;
20507  }
20508  case 22: {
20509  modelica_boolean tmp17;
20510  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,19,2) == 0) goto tmp3_end;
20511  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20512  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20513 
20514  _id = tmpMeta[2];
20515  _e1 = tmpMeta[3];
20516  _arg = tmp4_2;
20517  /* Pattern matching succeeded */
20518 #line 1717 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20519  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20520 #line 20520 OMC_FILE
20521 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20522  tmp17 = (modelica_boolean)referenceEq(_e1, _e1m);
20523 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20524  if(tmp17)
20525 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20526  {
20527 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20528  tmpMeta[3] = _inExp;
20529 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20530  }
20531 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20532  else
20533 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20534  {
20535 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20536  tmpMeta[2] = mmc_mk_box3(22, &Absyn_Exp_AS__desc, _id, _e1m);
20537 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20538  tmpMeta[3] = tmpMeta[2];
20539 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20540  }
20541 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20542  tmpMeta[0+0] = tmpMeta[3];
20543 #line 1718 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20544  tmpMeta[0+1] = _arg;
20545 #line 20545 OMC_FILE
20546  goto tmp3_done;
20547  }
20548  case 23: {
20549  modelica_boolean tmp18;
20550  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,20,2) == 0) goto tmp3_end;
20551  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20552  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20553 
20554  _e1 = tmpMeta[2];
20555  _e2 = tmpMeta[3];
20556  _arg = tmp4_2;
20557  /* Pattern matching succeeded */
20558 #line 1723 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20559  _e1m = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20560 #line 20560 OMC_FILE
20561 
20562 #line 1724 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20563  _e2m = omc_Absyn_traverseExpBidir(threadData, _e2, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20564 #line 20564 OMC_FILE
20565 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20566  tmp18 = (modelica_boolean)(referenceEq(_e1, _e1m) && referenceEq(_e2, _e2m));
20567 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20568  if(tmp18)
20569 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20570  {
20571 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20572  tmpMeta[3] = _inExp;
20573 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20574  }
20575 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20576  else
20577 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20578  {
20579 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20580  tmpMeta[2] = mmc_mk_box3(23, &Absyn_Exp_CONS__desc, _e1m, _e2m);
20581 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20582  tmpMeta[3] = tmpMeta[2];
20583 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20584  }
20585 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20586  tmpMeta[0+0] = tmpMeta[3];
20587 #line 1725 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20588  tmpMeta[0+1] = _arg;
20589 #line 20589 OMC_FILE
20590  goto tmp3_done;
20591  }
20592  case 24: {
20593  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,21,5) == 0) goto tmp3_end;
20594  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20595  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
20596  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
20597  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
20598  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 6));
20599 
20600  _match_ty = tmpMeta[2];
20601  _e1 = tmpMeta[3];
20602  _match_decls = tmpMeta[4];
20603  _match_cases = tmpMeta[5];
20604  _cmt = tmpMeta[6];
20605  _arg = tmp4_2;
20606  /* Pattern matching succeeded */
20607 #line 1731 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20608  _e1 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20609 #line 20609 OMC_FILE
20610 
20611 #line 1732 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20612  _match_cases = omc_List_map2FoldCheckReferenceEq(threadData, _match_cases, boxvar_Absyn_traverseMatchCase, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20613 #line 20613 OMC_FILE
20614 #line 1733 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20615  tmpMeta[2] = mmc_mk_box6(24, &Absyn_Exp_MATCHEXP__desc, _match_ty, _e1, _match_decls, _match_cases, _cmt);
20616 #line 1733 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20617  tmpMeta[0+0] = tmpMeta[2];
20618 #line 1733 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20619  tmpMeta[0+1] = _arg;
20620 #line 20620 OMC_FILE
20621  goto tmp3_done;
20622  }
20623  case 25: {
20624  modelica_boolean tmp19;
20625  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,22,1) == 0) goto tmp3_end;
20626  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
20627 
20628  _expl1 = tmpMeta[2];
20629  _arg = tmp4_2;
20630  /* Pattern matching succeeded */
20631 #line 1738 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20632  _expl2 = omc_Absyn_traverseExpListBidir(threadData, _expl1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20633 #line 20633 OMC_FILE
20634 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20635  tmp19 = (modelica_boolean)referenceEq(_expl1, _expl2);
20636 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20637  if(tmp19)
20638 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20639  {
20640 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20641  tmpMeta[3] = _inExp;
20642 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20643  }
20644 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20645  else
20646 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20647  {
20648 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20649  tmpMeta[2] = mmc_mk_box2(25, &Absyn_Exp_LIST__desc, _expl2);
20650 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20651  tmpMeta[3] = tmpMeta[2];
20652 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20653  }
20654 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20655  tmpMeta[0+0] = tmpMeta[3];
20656 #line 1739 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20657  tmpMeta[0+1] = _arg;
20658 #line 20658 OMC_FILE
20659  goto tmp3_done;
20660  }
20661  case 21: {
20662  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,18,1) == 0) goto tmp3_end;
20663 
20664  /* Pattern matching succeeded */
20665 #line 1743 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20666  tmpMeta[0+0] = _inExp;
20667 #line 1743 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20668  tmpMeta[0+1] = _inArg;
20669 #line 20669 OMC_FILE
20670  goto tmp3_done;
20671  }
20672  case 26: {
20673  modelica_boolean tmp20;
20674  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,23,2) == 0) goto tmp3_end;
20675 
20676  _arg = tmp4_2;
20677  /* Pattern matching succeeded */
20678 #line 1747 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20679  _e1 = omc_Absyn_traverseExpBidir(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 2))), ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20680 #line 20680 OMC_FILE
20681 
20682 #line 1748 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20683  _e2 = omc_Absyn_traverseExpBidir(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 3))), ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
20684 #line 20684 OMC_FILE
20685 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20686  tmp20 = (modelica_boolean)(referenceEq((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 2))), _e1) && referenceEq((MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inExp), 3))), _e2));
20687 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20688  if(tmp20)
20689 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20690  {
20691 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20692  tmpMeta[3] = _inExp;
20693 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20694  }
20695 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20696  else
20697 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20698  {
20699 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20700  tmpMeta[2] = mmc_mk_box3(26, &Absyn_Exp_DOT__desc, _e1, _e2);
20701 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20702  tmpMeta[3] = tmpMeta[2];
20703 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20704  }
20705 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20706  tmpMeta[0+0] = tmpMeta[3];
20707 #line 1749 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20708  tmpMeta[0+1] = _arg;
20709 #line 20709 OMC_FILE
20710  goto tmp3_done;
20711  }
20712  default:
20713  tmp3_default: OMC_LABEL_UNUSED; {
20714 
20715  /* Pattern matching succeeded */
20716 #line 1754 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20717  omc_System_dladdr(threadData, ((modelica_fnptr) _enterFunc) ,NULL ,&_enterName);
20718 #line 20718 OMC_FILE
20719 
20720 #line 1755 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20721  omc_System_dladdr(threadData, ((modelica_fnptr) _exitFunc) ,NULL ,&_exitName);
20722 #line 20722 OMC_FILE
20723 
20724 #line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20725  tmpMeta[2] = stringAppend(_OMC_LIT59,_enterName);
20726 #line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20727  tmpMeta[3] = stringAppend(tmpMeta[2],_OMC_LIT3);
20728 #line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20729  tmpMeta[4] = stringAppend(tmpMeta[3],_exitName);
20730 #line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20731  tmpMeta[5] = stringAppend(tmpMeta[4],_OMC_LIT60);
20732 #line 1756 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20733  _error_msg = tmpMeta[5];
20734 #line 20734 OMC_FILE
20735 
20736 #line 1757 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20737  tmpMeta[2] = stringAppend(_error_msg,omc_Dump_printExpStr(threadData, _inExp));
20738 #line 1757 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20739  _error_msg = tmpMeta[2];
20740 #line 20740 OMC_FILE
20741 
20742 #line 1758 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20743  tmpMeta[2] = mmc_mk_cons(_error_msg, MMC_REFSTRUCTLIT(mmc_nil));
20744 #line 1758 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20745  omc_Error_addMessage(threadData, _OMC_LIT65, tmpMeta[2]);
20746 #line 20746 OMC_FILE
20747 #line 1759 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20748  goto goto_2;
20749 #line 20749 OMC_FILE
20750  goto tmp3_done;
20751  }
20752  }
20753  goto tmp3_end;
20754  tmp3_end: ;
20755  }
20756  goto goto_2;
20757  goto_2:;
20758  MMC_THROW_INTERNAL();
20759  goto tmp3_done;
20760  tmp3_done:;
20761  }
20762  }
20763  _e = tmpMeta[0+0];
20764  _arg = tmpMeta[0+1];
20765  _return: OMC_LABEL_UNUSED
20766  if (out_arg) { *out_arg = _arg; }
20767  return _e;
20768 }
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_TUPLE__desc
modelica_metatype modelica_string
signed char modelica_boolean
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_MATRIX__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_UNARY__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_CONS__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_CREF__desc
DLLExport modelica_string omc_System_dladdr(threadData_t *threadData, modelica_metatype _symbol, modelica_string *out_file, modelica_string *out_name)
Definition: System.c:336
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_LBINARY__desc
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_PARTEVALFUNCTION__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_MATCHEXP__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_CALL__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_AS__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_DOT__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_ARRAY__desc
DLLExport modelica_metatype omc_Absyn_traverseExpOptBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20771
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_LIST__desc
modelica_string stringAppend(modelica_string s1, modelica_string s2)
DLLExport void omc_Error_addMessage(threadData_t *threadData, modelica_metatype _inErrorMsg, modelica_metatype _inMessageTokens)
Definition: Error.c:1082
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_LUNARY__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_BINARY__desc
DLLExport modelica_metatype omc_Absyn_traverseExpBidirCref(threadData_t *threadData, modelica_metatype _inCref, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:19702
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_traverseExpListBidir(threadData_t *threadData, modelica_metatype _inExpl, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:20861
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_RELATION__desc
DLLExport modelica_string omc_Dump_printExpStr(threadData_t *threadData, modelica_metatype _inExp)
Definition: Dump.c:10422
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_IFEXP__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
DLLExport modelica_metatype omc_Absyn_traverseExpBidirFunctionArgs(threadData_t *threadData, modelica_metatype _inArgs, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:19426
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Exp_RANGE__desc
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpBidirSubs()

DLLExport modelica_metatype omc_Absyn_traverseExpBidirSubs ( threadData_t threadData,
modelica_metatype  _inSubscript,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_arg 
)

Definition at line 19610 of file Absyn.c.

19611 {
19612  modelica_metatype _outSubscript = NULL;
19613  modelica_metatype _arg = NULL;
19614  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
19615  MMC_SO();
19616  _tailrecursive: OMC_LABEL_UNUSED
19617 #line 1835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19618 
19619 #line 1835 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19620 
19621 #line 19621 OMC_FILE
19622  { /* match expression */
19623  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
19624  tmp4_1 = _inSubscript;
19625  tmp4_2 = _inArg;
19626  {
19627  modelica_metatype _e1 = NULL;
19628  modelica_metatype _e2 = NULL;
19629  volatile mmc_switch_type tmp4;
19630  int tmp5;
19631  tmp4 = 0;
19632  for (; tmp4 < 2; tmp4++) {
19633  switch (MMC_SWITCH_CAST(tmp4)) {
19634  case 0: {
19635  modelica_boolean tmp6;
19636  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,1) == 0) goto tmp3_end;
19637  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19638 
19639  _e1 = tmpMeta[2];
19640  _arg = tmp4_2;
19641  /* Pattern matching succeeded */
19642 #line 1841 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19643  _e2 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
19644 #line 19644 OMC_FILE
19645 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19646  tmp6 = (modelica_boolean)referenceEq(_e1, _e2);
19647 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19648  if(tmp6)
19649 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19650  {
19651 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19652  tmpMeta[3] = _inSubscript;
19653 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19654  }
19655 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19656  else
19657 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19658  {
19659 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19660  tmpMeta[2] = mmc_mk_box2(4, &Absyn_Subscript_SUBSCRIPT__desc, _e2);
19661 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19662  tmpMeta[3] = tmpMeta[2];
19663 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19664  }
19665 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19666  tmpMeta[0+0] = tmpMeta[3];
19667 #line 1842 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19668  tmpMeta[0+1] = _arg;
19669 #line 19669 OMC_FILE
19670  goto tmp3_done;
19671  }
19672  case 1: {
19673  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,0) == 0) goto tmp3_end;
19674 
19675  /* Pattern matching succeeded */
19676 #line 1845 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19677  tmpMeta[0+0] = _inSubscript;
19678 #line 1845 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19679  tmpMeta[0+1] = _inArg;
19680 #line 19680 OMC_FILE
19681  goto tmp3_done;
19682  }
19683  }
19684  goto tmp3_end;
19685  tmp3_end: ;
19686  }
19687  goto goto_2;
19688  goto_2:;
19689  MMC_THROW_INTERNAL();
19690  goto tmp3_done;
19691  tmp3_done:;
19692  }
19693  }
19694  _outSubscript = tmpMeta[0+0];
19695  _arg = tmpMeta[0+1];
19696  _return: OMC_LABEL_UNUSED
19697  if (out_arg) { *out_arg = _arg; }
19698  return _outSubscript;
19699 }
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Subscript_SUBSCRIPT__desc
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseExpEqItemTupleList()

DLLExport modelica_metatype omc_Absyn_traverseExpEqItemTupleList ( threadData_t threadData,
modelica_metatype  _inList,
modelica_fnptr  _inFunc,
modelica_metatype  _inTypeA 
)

Definition at line 21638 of file Absyn.c.

21639 {
21640  modelica_metatype _outTpl = NULL;
21641  modelica_metatype _arg2 = NULL;
21642  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
21643  MMC_SO();
21644  _tailrecursive: OMC_LABEL_UNUSED
21645  _arg2 = _inTypeA;
21646 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21647  {
21648 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21649  modelica_metatype _$tmpVar17;
21650 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21651  modelica_metatype* tmp1;
21652 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21653  modelica_metatype _$tmpVar16;
21654 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21655  int tmp6;
21656 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21657  modelica_metatype el_loopVar = 0;
21658 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21659  modelica_metatype _el;
21660 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21661  el_loopVar = _inList;
21662 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21663  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
21664 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21665  _$tmpVar17 = tmpMeta[1]; /* defaultValue */
21666 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21667  tmp1 = &_$tmpVar17;
21668 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21669  while(1) {
21670 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21671  tmp6 = 1;
21672 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21673  if (!listEmpty(el_loopVar)) {
21674 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21675  _el = MMC_CAR(el_loopVar);
21676 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21677  el_loopVar = MMC_CDR(el_loopVar);
21678 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21679  tmp6--;
21680 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21681  }
21682 #line 1269 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21683  if (tmp6 == 0) {
21684 #line 21684 OMC_FILE
21685  { /* match expression */
21686  modelica_metatype tmp4_1;
21687  tmp4_1 = _el;
21688  {
21689  modelica_metatype _e = NULL;
21690  modelica_metatype _eilst = NULL;
21691  modelica_metatype _eilst_1 = NULL;
21692  volatile mmc_switch_type tmp4;
21693  int tmp5;
21694  tmp4 = 0;
21695  for (; tmp4 < 1; tmp4++) {
21696  switch (MMC_SWITCH_CAST(tmp4)) {
21697  case 0: {
21698  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
21699  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
21700  _e = tmpMeta[3];
21701  _eilst = tmpMeta[4];
21702  /* Pattern matching succeeded */
21703 #line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21704  /* Pattern-matching assignment */
21705 #line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21706  tmpMeta[3] = omc_Absyn_traverseEquationItemList(threadData, _eilst, ((modelica_fnptr) _inFunc), _arg2);
21707 #line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21708  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 1));
21709 #line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21710  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[3]), 2));
21711 #line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21712  _eilst_1 = tmpMeta[4];
21713 #line 1274 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21714  _arg2 = tmpMeta[5];
21715 #line 21715 OMC_FILE
21716 #line 1275 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21717  tmpMeta[3] = mmc_mk_box2(0, _e, _eilst_1);
21718 #line 1275 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
21719  tmpMeta[2] = tmpMeta[3];
21720 #line 21720 OMC_FILE
21721  goto tmp3_done;
21722  }
21723  }
21724  goto tmp3_end;
21725  tmp3_end: ;
21726  }
21727  goto goto_2;
21728  goto_2:;
21729  MMC_THROW_INTERNAL();
21730  goto tmp3_done;
21731  tmp3_done:;
21732  }
21733  }_$tmpVar16 = tmpMeta[2];
21734  *tmp1 = mmc_mk_cons(_$tmpVar16,0);
21735  tmp1 = &MMC_CDR(*tmp1);
21736  } else if (tmp6 == 1) {
21737  break;
21738  } else {
21739  MMC_THROW_INTERNAL();
21740  }
21741  }
21742  *tmp1 = mmc_mk_nil();
21743  tmpMeta[0] = _$tmpVar17;
21744  }
21745  tmpMeta[4] = mmc_mk_box2(0, tmpMeta[0], _arg2);
21746  _outTpl = tmpMeta[4];
21747  _return: OMC_LABEL_UNUSED
21748  return _outTpl;
21749 }
DLLExport modelica_metatype omc_Absyn_traverseEquationItemList(threadData_t *threadData, modelica_metatype _inEquationItemList, modelica_fnptr _inFunc, modelica_metatype _inTypeA)
Definition: Absyn.c:21752
float mmc_switch_type
void * modelica_fnptr
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpList()

DLLExport modelica_metatype omc_Absyn_traverseExpList ( threadData_t threadData,
modelica_metatype  _inExpList,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 20876 of file Absyn.c.

20877 {
20878  modelica_metatype _outExpList = NULL;
20879  modelica_metatype _outArg = NULL;
20880  MMC_SO();
20881  _tailrecursive: OMC_LABEL_UNUSED
20882 #line 1496 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20883  _outExpList = omc_Absyn_traverseExpListBidir(threadData, _inExpList, boxvar_Absyn_dummyTraverseExp, ((modelica_fnptr) _inFunc), _inArg ,&_outArg);
20884 #line 20884 OMC_FILE
20885  _return: OMC_LABEL_UNUSED
20886  if (out_outArg) { *out_outArg = _outArg; }
20887  return _outExpList;
20888 }
void * modelica_fnptr
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_traverseExpListBidir(threadData_t *threadData, modelica_metatype _inExpl, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:20861
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpListBidir()

DLLExport modelica_metatype omc_Absyn_traverseExpListBidir ( threadData_t threadData,
modelica_metatype  _inExpl,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 20861 of file Absyn.c.

20862 {
20863  modelica_metatype _outExpl = NULL;
20864  modelica_metatype _outArg = NULL;
20865  MMC_SO();
20866  _tailrecursive: OMC_LABEL_UNUSED
20867 #line 1517 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20868  _outExpl = omc_List_map2FoldCheckReferenceEq(threadData, _inExpl, boxvar_Absyn_traverseExpBidir, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_outArg);
20869 #line 20869 OMC_FILE
20870  _return: OMC_LABEL_UNUSED
20871  if (out_outArg) { *out_outArg = _outArg; }
20872  return _outExpl;
20873 }
void * modelica_fnptr
DLLExport modelica_metatype omc_List_map2FoldCheckReferenceEq(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc, modelica_metatype _inConstArg, modelica_metatype _inConstArg2, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: List.c:8673
void * modelica_metatype
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpOptBidir()

DLLExport modelica_metatype omc_Absyn_traverseExpOptBidir ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_arg 
)

Definition at line 20771 of file Absyn.c.

20772 {
20773  modelica_metatype _outExp = NULL;
20774  modelica_metatype _arg = NULL;
20775  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
20776  MMC_SO();
20777  _tailrecursive: OMC_LABEL_UNUSED
20778 #line 1569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20779 
20780 #line 1569 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20781 
20782 #line 20782 OMC_FILE
20783  { /* match expression */
20784  modelica_metatype tmp4_1;
20785  tmp4_1 = _inExp;
20786  {
20787  modelica_metatype _e1 = NULL;
20788  modelica_metatype _e2 = NULL;
20789  volatile mmc_switch_type tmp4;
20790  int tmp5;
20791  tmp4 = 0;
20792  for (; tmp4 < 2; tmp4++) {
20793  switch (MMC_SWITCH_CAST(tmp4)) {
20794  case 0: {
20795  if (optionNone(tmp4_1)) goto tmp3_end;
20796  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 1));
20797  _e1 = tmpMeta[2];
20798  /* Pattern matching succeeded */
20799 #line 1576 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20800  _e2 = omc_Absyn_traverseExpBidir(threadData, _e1, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _inArg ,&_arg);
20801 #line 20801 OMC_FILE
20802 #line 1577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20803  tmpMeta[0+0] = (referenceEq(_e1, _e2)?_inExp:mmc_mk_some(_e2));
20804 #line 1577 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20805  tmpMeta[0+1] = _arg;
20806 #line 20806 OMC_FILE
20807  goto tmp3_done;
20808  }
20809  case 1: {
20810 
20811  /* Pattern matching succeeded */
20812 #line 1580 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20813  tmpMeta[0+0] = _inExp;
20814 #line 1580 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20815  tmpMeta[0+1] = _inArg;
20816 #line 20816 OMC_FILE
20817  goto tmp3_done;
20818  }
20819  }
20820  goto tmp3_end;
20821  tmp3_end: ;
20822  }
20823  goto goto_2;
20824  goto_2:;
20825  MMC_THROW_INTERNAL();
20826  goto tmp3_done;
20827  tmp3_done:;
20828  }
20829  }
20830  _outExp = tmpMeta[0+0];
20831  _arg = tmpMeta[0+1];
20832  _return: OMC_LABEL_UNUSED
20833  if (out_arg) { *out_arg = _arg; }
20834  return _outExp;
20835 }
float mmc_switch_type
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseExpShallow()

DLLExport modelica_metatype omc_Absyn_traverseExpShallow ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_metatype  _inArg,
modelica_fnptr  _inFunc 
)

Definition at line 1246 of file Absyn.c.

1247 {
1248  modelica_metatype _outExp = NULL;
1249  modelica_metatype tmpMeta[5] __attribute__((unused)) = {0};
1250  MMC_SO();
1251  _tailrecursive: OMC_LABEL_UNUSED
1252  _outExp = _inExp;
1253 #line 1253 OMC_FILE
1254  { /* match expression */
1255  modelica_metatype tmp3_1;
1256  tmp3_1 = _outExp;
1257  {
1258  int tmp3;
1259  {
1260  switch (MMC_SWITCH_CAST(valueConstructor(tmp3_1))) {
1261  case 8: {
1262 
1263  /* Pattern matching succeeded */
1264 #line 6607 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1265  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1266 #line 6607 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1267  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1268 #line 6607 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1269  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
1270 #line 6607 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1271  _outExp = tmpMeta[0];
1272 #line 1272 OMC_FILE
1273 
1274 #line 6608 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1275  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1276 #line 6608 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1277  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1278 #line 6608 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1279  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
1280 #line 6608 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1281  _outExp = tmpMeta[0];
1282 #line 1282 OMC_FILE
1283 #line 1283 OMC_FILE
1284  goto tmp2_done;
1285  }
1286  case 9: {
1287 
1288  /* Pattern matching succeeded */
1289 #line 6614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1290  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1291 #line 6614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1292  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1293 #line 6614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1294  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
1295 #line 6614 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1296  _outExp = tmpMeta[0];
1297 #line 1297 OMC_FILE
1298 #line 1298 OMC_FILE
1299  goto tmp2_done;
1300  }
1301  case 10: {
1302 
1303  /* Pattern matching succeeded */
1304 #line 6620 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1305  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1306 #line 6620 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1307  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1308 #line 6620 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1309  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
1310 #line 6620 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1311  _outExp = tmpMeta[0];
1312 #line 1312 OMC_FILE
1313 
1314 #line 6621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1315  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1316 #line 6621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1317  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1318 #line 6621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1319  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
1320 #line 6621 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1321  _outExp = tmpMeta[0];
1322 #line 1322 OMC_FILE
1323 #line 1323 OMC_FILE
1324  goto tmp2_done;
1325  }
1326  case 11: {
1327 
1328  /* Pattern matching succeeded */
1329 #line 6627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1330  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1331 #line 6627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1332  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1333 #line 6627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1334  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
1335 #line 6627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1336  _outExp = tmpMeta[0];
1337 #line 1337 OMC_FILE
1338 #line 1338 OMC_FILE
1339  goto tmp2_done;
1340  }
1341  case 12: {
1342 
1343  /* Pattern matching succeeded */
1344 #line 6633 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1345  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1346 #line 6633 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1347  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1348 #line 6633 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1349  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
1350 #line 6633 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1351  _outExp = tmpMeta[0];
1352 #line 1352 OMC_FILE
1353 
1354 #line 6634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1355  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1356 #line 6634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1357  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1358 #line 6634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1359  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
1360 #line 6634 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1361  _outExp = tmpMeta[0];
1362 #line 1362 OMC_FILE
1363 #line 1363 OMC_FILE
1364  goto tmp2_done;
1365  }
1366  case 13: {
1367 
1368  /* Pattern matching succeeded */
1369 #line 6640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1370  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(6));
1371 #line 6640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1372  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 6*sizeof(modelica_metatype));
1373 #line 6640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1374  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
1375 #line 6640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1376  _outExp = tmpMeta[0];
1377 #line 1377 OMC_FILE
1378 
1379 #line 6641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1380  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(6));
1381 #line 6641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1382  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 6*sizeof(modelica_metatype));
1383 #line 6641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1384  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
1385 #line 6641 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1386  _outExp = tmpMeta[0];
1387 #line 1387 OMC_FILE
1388 
1389 #line 6642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1390  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(6));
1391 #line 6642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1392  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 6*sizeof(modelica_metatype));
1393 #line 6642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1394  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
1395 #line 6642 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1396  _outExp = tmpMeta[0];
1397 #line 1397 OMC_FILE
1398 
1399 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1400  {
1401 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1402  modelica_metatype _$tmpVar5;
1403 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1404  modelica_metatype* tmp4;
1405 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1406  modelica_metatype _$tmpVar4;
1407 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1408  int tmp5;
1409 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1410  modelica_metatype e_loopVar = 0;
1411 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1412  modelica_metatype _e;
1413 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1414  e_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 5)));
1415 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1416  tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
1417 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1418  _$tmpVar5 = tmpMeta[2]; /* defaultValue */
1419 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1420  tmp4 = &_$tmpVar5;
1421 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1422  while(1) {
1423 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1424  tmp5 = 1;
1425 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1426  if (!listEmpty(e_loopVar)) {
1427 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1428  _e = MMC_CAR(e_loopVar);
1429 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1430  e_loopVar = MMC_CDR(e_loopVar);
1431 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1432  tmp5--;
1433 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1434  }
1435 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1436  if (tmp5 == 0) {
1437 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1438  tmpMeta[3] = mmc_mk_box2(0, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), omc_Util_tuple21(threadData, _e), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, omc_Util_tuple21(threadData, _e), _inArg), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), omc_Util_tuple22(threadData, _e), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, omc_Util_tuple22(threadData, _e), _inArg));
1439 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1440  _$tmpVar4 = tmpMeta[3];
1441 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1442  *tmp4 = mmc_mk_cons(_$tmpVar4,0);
1443 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1444  tmp4 = &MMC_CDR(*tmp4);
1445 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1446  } else if (tmp5 == 1) {
1447 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1448  break;
1449 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1450  } else {
1451 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1452  goto goto_1;
1453 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1454  }
1455 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1456  }
1457 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1458  *tmp4 = mmc_mk_nil();
1459 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1460  tmpMeta[1] = _$tmpVar5;
1461 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1462  }
1463 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1464  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(6));
1465 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1466  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 6*sizeof(modelica_metatype));
1467 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1468  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[5] = tmpMeta[1];
1469 #line 6643 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1470  _outExp = tmpMeta[0];
1471 #line 1471 OMC_FILE
1472 #line 1472 OMC_FILE
1473  goto tmp2_done;
1474  }
1475  case 14: {
1476 
1477  /* Pattern matching succeeded */
1478 #line 6650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1479  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1480 #line 6650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1481  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1482 #line 6650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1483  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = omc_Absyn_traverseExpShallowFuncArgs(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg, ((modelica_fnptr) _inFunc));
1484 #line 6650 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1485  _outExp = tmpMeta[0];
1486 #line 1486 OMC_FILE
1487 #line 1487 OMC_FILE
1488  goto tmp2_done;
1489  }
1490  case 15: {
1491 
1492  /* Pattern matching succeeded */
1493 #line 6657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1494  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1495 #line 6657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1496  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1497 #line 6657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1498  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = omc_Absyn_traverseExpShallowFuncArgs(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg, ((modelica_fnptr) _inFunc));
1499 #line 6657 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1500  _outExp = tmpMeta[0];
1501 #line 1501 OMC_FILE
1502 #line 1502 OMC_FILE
1503  goto tmp2_done;
1504  }
1505  case 16: {
1506 
1507  /* Pattern matching succeeded */
1508 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1509  {
1510 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1511  modelica_metatype _$tmpVar7;
1512 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1513  modelica_metatype* tmp6;
1514 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1515  modelica_metatype _$tmpVar6;
1516 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1517  int tmp7;
1518 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1519  modelica_metatype e_loopVar = 0;
1520 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1521  modelica_metatype _e;
1522 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1523  e_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2)));
1524 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1525  tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
1526 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1527  _$tmpVar7 = tmpMeta[2]; /* defaultValue */
1528 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1529  tmp6 = &_$tmpVar7;
1530 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1531  while(1) {
1532 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1533  tmp7 = 1;
1534 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1535  if (!listEmpty(e_loopVar)) {
1536 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1537  _e = MMC_CAR(e_loopVar);
1538 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1539  e_loopVar = MMC_CDR(e_loopVar);
1540 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1541  tmp7--;
1542 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1543  }
1544 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1545  if (tmp7 == 0) {
1546 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1547  _$tmpVar6 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _inArg);
1548 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1549  *tmp6 = mmc_mk_cons(_$tmpVar6,0);
1550 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1551  tmp6 = &MMC_CDR(*tmp6);
1552 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1553  } else if (tmp7 == 1) {
1554 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1555  break;
1556 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1557  } else {
1558 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1559  goto goto_1;
1560 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1561  }
1562 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1563  }
1564 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1565  *tmp6 = mmc_mk_nil();
1566 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1567  tmpMeta[1] = _$tmpVar7;
1568 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1569  }
1570 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1571  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
1572 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1573  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 3*sizeof(modelica_metatype));
1574 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1575  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = tmpMeta[1];
1576 #line 6664 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1577  _outExp = tmpMeta[0];
1578 #line 1578 OMC_FILE
1579 #line 1579 OMC_FILE
1580  goto tmp2_done;
1581  }
1582  case 17: {
1583 
1584  /* Pattern matching succeeded */
1585 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1586  {
1587 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1588  modelica_metatype _$tmpVar11;
1589 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1590  modelica_metatype* tmp8;
1591 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1592  modelica_metatype _$tmpVar10;
1593 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1594  int tmp11;
1595 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1596  modelica_metatype lst_loopVar = 0;
1597 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1598  modelica_metatype _lst;
1599 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1600  lst_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2)));
1601 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1602  tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
1603 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1604  _$tmpVar11 = tmpMeta[2]; /* defaultValue */
1605 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1606  tmp8 = &_$tmpVar11;
1607 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1608  while(1) {
1609 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1610  tmp11 = 1;
1611 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1612  if (!listEmpty(lst_loopVar)) {
1613 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1614  _lst = MMC_CAR(lst_loopVar);
1615 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1616  lst_loopVar = MMC_CDR(lst_loopVar);
1617 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1618  tmp11--;
1619 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1620  }
1621 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1622  if (tmp11 == 0) {
1623 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1624  {
1625 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1626  modelica_metatype _$tmpVar9;
1627 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1628  modelica_metatype* tmp9;
1629 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1630  modelica_metatype _$tmpVar8;
1631 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1632  int tmp10;
1633 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1634  modelica_metatype e_loopVar = 0;
1635 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1636  modelica_metatype _e;
1637 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1638  e_loopVar = _lst;
1639 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1640  tmpMeta[4] = MMC_REFSTRUCTLIT(mmc_nil);
1641 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1642  _$tmpVar9 = tmpMeta[4]; /* defaultValue */
1643 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1644  tmp9 = &_$tmpVar9;
1645 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1646  while(1) {
1647 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1648  tmp10 = 1;
1649 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1650  if (!listEmpty(e_loopVar)) {
1651 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1652  _e = MMC_CAR(e_loopVar);
1653 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1654  e_loopVar = MMC_CDR(e_loopVar);
1655 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1656  tmp10--;
1657 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1658  }
1659 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1660  if (tmp10 == 0) {
1661 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1662  _$tmpVar8 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _inArg);
1663 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1664  *tmp9 = mmc_mk_cons(_$tmpVar8,0);
1665 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1666  tmp9 = &MMC_CDR(*tmp9);
1667 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1668  } else if (tmp10 == 1) {
1669 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1670  break;
1671 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1672  } else {
1673 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1674  goto goto_1;
1675 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1676  }
1677 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1678  }
1679 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1680  *tmp9 = mmc_mk_nil();
1681 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1682  tmpMeta[3] = _$tmpVar9;
1683 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1684  }
1685 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1686  _$tmpVar10 = tmpMeta[3];
1687 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1688  *tmp8 = mmc_mk_cons(_$tmpVar10,0);
1689 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1690  tmp8 = &MMC_CDR(*tmp8);
1691 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1692  } else if (tmp11 == 1) {
1693 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1694  break;
1695 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1696  } else {
1697 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1698  goto goto_1;
1699 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1700  }
1701 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1702  }
1703 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1704  *tmp8 = mmc_mk_nil();
1705 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1706  tmpMeta[1] = _$tmpVar11;
1707 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1708  }
1709 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1710  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
1711 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1712  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 3*sizeof(modelica_metatype));
1713 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1714  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = tmpMeta[1];
1715 #line 6670 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1716  _outExp = tmpMeta[0];
1717 #line 1717 OMC_FILE
1718 #line 1718 OMC_FILE
1719  goto tmp2_done;
1720  }
1721  case 18: {
1722 
1723  /* Pattern matching succeeded */
1724 #line 6677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1725  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1726 #line 6677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1727  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1728 #line 6677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1729  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
1730 #line 6677 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1731  _outExp = tmpMeta[0];
1732 #line 1732 OMC_FILE
1733 
1734 #line 6678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1735  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1736 #line 6678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1737  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1738 #line 6678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1739  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = omc_Util_applyOption1(threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), ((modelica_fnptr) _inFunc), _inArg);
1740 #line 6678 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1741  _outExp = tmpMeta[0];
1742 #line 1742 OMC_FILE
1743 
1744 #line 6679 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1745  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(5));
1746 #line 6679 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1747  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 5*sizeof(modelica_metatype));
1748 #line 6679 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1749  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[4] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 4))), _inArg);
1750 #line 6679 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1751  _outExp = tmpMeta[0];
1752 #line 1752 OMC_FILE
1753 #line 1753 OMC_FILE
1754  goto tmp2_done;
1755  }
1756  case 19: {
1757 
1758  /* Pattern matching succeeded */
1759 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1760  {
1761 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1762  modelica_metatype _$tmpVar13;
1763 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1764  modelica_metatype* tmp12;
1765 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1766  modelica_metatype _$tmpVar12;
1767 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1768  int tmp13;
1769 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1770  modelica_metatype e_loopVar = 0;
1771 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1772  modelica_metatype _e;
1773 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1774  e_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2)));
1775 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1776  tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
1777 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1778  _$tmpVar13 = tmpMeta[2]; /* defaultValue */
1779 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1780  tmp12 = &_$tmpVar13;
1781 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1782  while(1) {
1783 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1784  tmp13 = 1;
1785 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1786  if (!listEmpty(e_loopVar)) {
1787 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1788  _e = MMC_CAR(e_loopVar);
1789 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1790  e_loopVar = MMC_CDR(e_loopVar);
1791 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1792  tmp13--;
1793 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1794  }
1795 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1796  if (tmp13 == 0) {
1797 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1798  _$tmpVar12 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _inArg);
1799 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1800  *tmp12 = mmc_mk_cons(_$tmpVar12,0);
1801 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1802  tmp12 = &MMC_CDR(*tmp12);
1803 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1804  } else if (tmp13 == 1) {
1805 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1806  break;
1807 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1808  } else {
1809 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1810  goto goto_1;
1811 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1812  }
1813 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1814  }
1815 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1816  *tmp12 = mmc_mk_nil();
1817 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1818  tmpMeta[1] = _$tmpVar13;
1819 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1820  }
1821 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1822  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
1823 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1824  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 3*sizeof(modelica_metatype));
1825 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1826  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = tmpMeta[1];
1827 #line 6685 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1828  _outExp = tmpMeta[0];
1829 #line 1829 OMC_FILE
1830 #line 1830 OMC_FILE
1831  goto tmp2_done;
1832  }
1833  case 22: {
1834 
1835  /* Pattern matching succeeded */
1836 #line 6691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1837  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1838 #line 6691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1839  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1840 #line 6691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1841  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
1842 #line 6691 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1843  _outExp = tmpMeta[0];
1844 #line 1844 OMC_FILE
1845 #line 1845 OMC_FILE
1846  goto tmp2_done;
1847  }
1848  case 23: {
1849 
1850  /* Pattern matching succeeded */
1851 #line 6697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1852  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1853 #line 6697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1854  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1855 #line 6697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1856  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
1857 #line 6697 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1858  _outExp = tmpMeta[0];
1859 #line 1859 OMC_FILE
1860 
1861 #line 6698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1862  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1863 #line 6698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1864  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1865 #line 6698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1866  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
1867 #line 6698 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1868  _outExp = tmpMeta[0];
1869 #line 1869 OMC_FILE
1870 #line 1870 OMC_FILE
1871  goto tmp2_done;
1872  }
1873  case 25: {
1874 
1875  /* Pattern matching succeeded */
1876 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1877  {
1878 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1879  modelica_metatype _$tmpVar15;
1880 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1881  modelica_metatype* tmp14;
1882 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1883  modelica_metatype _$tmpVar14;
1884 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1885  int tmp15;
1886 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1887  modelica_metatype e_loopVar = 0;
1888 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1889  modelica_metatype _e;
1890 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1891  e_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2)));
1892 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1893  tmpMeta[2] = MMC_REFSTRUCTLIT(mmc_nil);
1894 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1895  _$tmpVar15 = tmpMeta[2]; /* defaultValue */
1896 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1897  tmp14 = &_$tmpVar15;
1898 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1899  while(1) {
1900 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1901  tmp15 = 1;
1902 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1903  if (!listEmpty(e_loopVar)) {
1904 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1905  _e = MMC_CAR(e_loopVar);
1906 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1907  e_loopVar = MMC_CDR(e_loopVar);
1908 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1909  tmp15--;
1910 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1911  }
1912 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1913  if (tmp15 == 0) {
1914 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1915  _$tmpVar14 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _inArg);
1916 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1917  *tmp14 = mmc_mk_cons(_$tmpVar14,0);
1918 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1919  tmp14 = &MMC_CDR(*tmp14);
1920 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1921  } else if (tmp15 == 1) {
1922 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1923  break;
1924 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1925  } else {
1926 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1927  goto goto_1;
1928 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1929  }
1930 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1931  }
1932 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1933  *tmp14 = mmc_mk_nil();
1934 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1935  tmpMeta[1] = _$tmpVar15;
1936 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1937  }
1938 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1939  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(3));
1940 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1941  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 3*sizeof(modelica_metatype));
1942 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1943  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = tmpMeta[1];
1944 #line 6704 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1945  _outExp = tmpMeta[0];
1946 #line 1946 OMC_FILE
1947 #line 1947 OMC_FILE
1948  goto tmp2_done;
1949  }
1950  case 26: {
1951 
1952  /* Pattern matching succeeded */
1953 #line 6710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1954  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1955 #line 6710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1956  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1957 #line 6710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1958  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 2))), _inArg);
1959 #line 6710 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1960  _outExp = tmpMeta[0];
1961 #line 1961 OMC_FILE
1962 
1963 #line 6711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1964  tmpMeta[0] = MMC_TAGPTR(mmc_alloc_words(4));
1965 #line 6711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1966  memcpy(MMC_UNTAGPTR(tmpMeta[0]), MMC_UNTAGPTR(_outExp), 4*sizeof(modelica_metatype));
1967 #line 6711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1968  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[0]))[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outExp), 3))), _inArg);
1969 #line 6711 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1970  _outExp = tmpMeta[0];
1971 #line 1971 OMC_FILE
1972 #line 1972 OMC_FILE
1973  goto tmp2_done;
1974  }
1975  default:
1976  tmp2_default: OMC_LABEL_UNUSED; {
1977 
1978  /* Pattern matching succeeded */
1979 #line 1979 OMC_FILE
1980  goto tmp2_done;
1981  }
1982  }
1983  goto tmp2_end;
1984  tmp2_end: ;
1985  }
1986  goto goto_1;
1987  goto_1:;
1988  MMC_THROW_INTERNAL();
1989  goto tmp2_done;
1990  tmp2_done:;
1991  }
1992  }
1993  ;
1994  _return: OMC_LABEL_UNUSED
1995  return _outExp;
1996 }
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_fnptr
void * modelica_metatype
DLLExport modelica_metatype omc_Util_tuple21(threadData_t *threadData, modelica_metatype _inTuple)
Definition: Util.c:5354
DLLExport modelica_metatype omc_Util_applyOption1(threadData_t *threadData, modelica_metatype _inOption, modelica_fnptr _inFunc, modelica_metatype _inArg)
Definition: Util.c:3868
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpShallowFuncArgs(threadData_t *threadData, modelica_metatype _inArgs, modelica_metatype _inArg, modelica_fnptr _inFunc)
Definition: Absyn.c:1042
DLLExport modelica_metatype omc_Util_tuple22(threadData_t *threadData, modelica_metatype _inTuple)
Definition: Util.c:5334
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_traverseExpShallowFuncArgs()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpShallowFuncArgs ( threadData_t threadData,
modelica_metatype  _inArgs,
modelica_metatype  _inArg,
modelica_fnptr  _inFunc 
)

Definition at line 1042 of file Absyn.c.

1043 {
1044  modelica_metatype _outArgs = NULL;
1045  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
1046  MMC_SO();
1047  _tailrecursive: OMC_LABEL_UNUSED
1048  _outArgs = _inArgs;
1049 #line 1049 OMC_FILE
1050  { /* match expression */
1051  modelica_metatype tmp3_1;
1052  tmp3_1 = _outArgs;
1053  {
1054  volatile mmc_switch_type tmp3;
1055  int tmp4;
1056  tmp3 = 0;
1057  for (; tmp3 < 2; tmp3++) {
1058  switch (MMC_SWITCH_CAST(tmp3)) {
1059  case 0: {
1060  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
1061 
1062  /* Pattern matching succeeded */
1063 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1064  {
1065 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1066  modelica_metatype _$tmpVar1;
1067 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1068  modelica_metatype* tmp5;
1069 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1070  modelica_metatype _$tmpVar0;
1071 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1072  int tmp6;
1073 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1074  modelica_metatype arg_loopVar = 0;
1075 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1076  modelica_metatype _arg;
1077 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1078  arg_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outArgs), 2)));
1079 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1080  tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
1081 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1082  _$tmpVar1 = tmpMeta[3]; /* defaultValue */
1083 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1084  tmp5 = &_$tmpVar1;
1085 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1086  while(1) {
1087 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1088  tmp6 = 1;
1089 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1090  if (!listEmpty(arg_loopVar)) {
1091 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1092  _arg = MMC_CAR(arg_loopVar);
1093 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1094  arg_loopVar = MMC_CDR(arg_loopVar);
1095 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1096  tmp6--;
1097 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1098  }
1099 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1100  if (tmp6 == 0) {
1101 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1102  _$tmpVar0 = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _arg, _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _arg, _inArg);
1103 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1104  *tmp5 = mmc_mk_cons(_$tmpVar0,0);
1105 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1106  tmp5 = &MMC_CDR(*tmp5);
1107 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1108  } else if (tmp6 == 1) {
1109 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1110  break;
1111 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1112  } else {
1113 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1114  goto goto_1;
1115 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1116  }
1117 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1118  }
1119 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1120  *tmp5 = mmc_mk_nil();
1121 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1122  tmpMeta[2] = _$tmpVar1;
1123 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1124  }
1125 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1126  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(4));
1127 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1128  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outArgs), 4*sizeof(modelica_metatype));
1129 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1130  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = tmpMeta[2];
1131 #line 6734 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1132  _outArgs = tmpMeta[1];
1133 #line 1133 OMC_FILE
1134 #line 6735 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1135  tmpMeta[0] = _outArgs;
1136 #line 1136 OMC_FILE
1137  goto tmp2_done;
1138  }
1139  case 1: {
1140  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
1141 
1142  /* Pattern matching succeeded */
1143 #line 6740 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1144  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(5));
1145 #line 6740 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1146  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outArgs), 5*sizeof(modelica_metatype));
1147 #line 6740 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1148  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[2] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outArgs), 2))), _inArg) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outArgs), 2))), _inArg);
1149 #line 6740 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1150  _outArgs = tmpMeta[1];
1151 #line 1151 OMC_FILE
1152 
1153 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1154  {
1155 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1156  modelica_metatype _$tmpVar3;
1157 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1158  modelica_metatype* tmp7;
1159 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1160  modelica_metatype _$tmpVar2;
1161 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1162  int tmp8;
1163 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1164  modelica_metatype it_loopVar = 0;
1165 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1166  modelica_metatype _it;
1167 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1168  it_loopVar = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_outArgs), 4)));
1169 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1170  tmpMeta[3] = MMC_REFSTRUCTLIT(mmc_nil);
1171 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1172  _$tmpVar3 = tmpMeta[3]; /* defaultValue */
1173 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1174  tmp7 = &_$tmpVar3;
1175 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1176  while(1) {
1177 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1178  tmp8 = 1;
1179 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1180  if (!listEmpty(it_loopVar)) {
1181 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1182  _it = MMC_CAR(it_loopVar);
1183 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1184  it_loopVar = MMC_CDR(it_loopVar);
1185 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1186  tmp8--;
1187 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1188  }
1189 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1190  if (tmp8 == 0) {
1191 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1192  _$tmpVar2 = omc_Absyn_traverseExpShallowIterator(threadData, _it, _inArg, ((modelica_fnptr) _inFunc));
1193 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1194  *tmp7 = mmc_mk_cons(_$tmpVar2,0);
1195 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1196  tmp7 = &MMC_CDR(*tmp7);
1197 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1198  } else if (tmp8 == 1) {
1199 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1200  break;
1201 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1202  } else {
1203 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1204  goto goto_1;
1205 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1206  }
1207 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1208  }
1209 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1210  *tmp7 = mmc_mk_nil();
1211 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1212  tmpMeta[2] = _$tmpVar3;
1213 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1214  }
1215 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1216  tmpMeta[1] = MMC_TAGPTR(mmc_alloc_words(5));
1217 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1218  memcpy(MMC_UNTAGPTR(tmpMeta[1]), MMC_UNTAGPTR(_outArgs), 5*sizeof(modelica_metatype));
1219 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1220  ((modelica_metatype*)MMC_UNTAGPTR(tmpMeta[1]))[4] = tmpMeta[2];
1221 #line 6741 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1222  _outArgs = tmpMeta[1];
1223 #line 1223 OMC_FILE
1224 #line 6743 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1225  tmpMeta[0] = _outArgs;
1226 #line 1226 OMC_FILE
1227  goto tmp2_done;
1228  }
1229  }
1230  goto tmp2_end;
1231  tmp2_end: ;
1232  }
1233  goto goto_1;
1234  goto_1:;
1235  MMC_THROW_INTERNAL();
1236  goto tmp2_done;
1237  tmp2_done:;
1238  }
1239  }
1240  _outArgs = tmpMeta[0];
1241  _return: OMC_LABEL_UNUSED
1242  return _outArgs;
1243 }
float mmc_switch_type
void * memcpy(void *UA_RESTRICT dest, const void *UA_RESTRICT src, size_t n)
void * modelica_fnptr
void * modelica_metatype
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpShallowIterator(threadData_t *threadData, modelica_metatype _inIterator, modelica_metatype _inArg, modelica_fnptr _inFunc)
Definition: Absyn.c:998
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_traverseExpShallowIterator()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseExpShallowIterator ( threadData_t threadData,
modelica_metatype  _inIterator,
modelica_metatype  _inArg,
modelica_fnptr  _inFunc 
)

Definition at line 998 of file Absyn.c.

999 {
1000  modelica_metatype _outIterator = NULL;
1001  modelica_string _name = NULL;
1002  modelica_metatype _guard_exp = NULL;
1003  modelica_metatype _range_exp = NULL;
1004  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
1005  MMC_SO();
1006  _tailrecursive: OMC_LABEL_UNUSED
1007 #line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1008  /* Pattern-matching assignment */
1009 #line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1010  tmpMeta[0] = _inIterator;
1011 #line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1012  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 2));
1013 #line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1014  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 3));
1015 #line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1016  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[0]), 4));
1017 #line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1018  _name = tmpMeta[1];
1019 #line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1020  _guard_exp = tmpMeta[2];
1021 #line 6764 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1022  _range_exp = tmpMeta[3];
1023 #line 1023 OMC_FILE
1024 
1025 #line 6765 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1026  _guard_exp = omc_Util_applyOption1(threadData, _guard_exp, ((modelica_fnptr) _inFunc), _inArg);
1027 #line 1027 OMC_FILE
1028 
1029 #line 6766 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1030  _range_exp = omc_Util_applyOption1(threadData, _range_exp, ((modelica_fnptr) _inFunc), _inArg);
1031 #line 1031 OMC_FILE
1032 
1033 #line 6767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1034  tmpMeta[0] = mmc_mk_box4(3, &Absyn_ForIterator_ITERATOR__desc, _name, _guard_exp, _range_exp);
1035 #line 6767 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
1036  _outIterator = tmpMeta[0];
1037 #line 1037 OMC_FILE
1038  _return: OMC_LABEL_UNUSED
1039  return _outIterator;
1040 }
modelica_metatype modelica_string
void * modelica_fnptr
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_ForIterator_ITERATOR__desc
DLLExport modelica_metatype omc_Util_applyOption1(threadData_t *threadData, modelica_metatype _inOption, modelica_fnptr _inFunc, modelica_metatype _inArg)
Definition: Util.c:3868
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_traverseExpTopDown()

DLLExport modelica_metatype omc_Absyn_traverseExpTopDown ( threadData_t threadData,
modelica_metatype  _inExp,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 20891 of file Absyn.c.

20892 {
20893  modelica_metatype _outExp = NULL;
20894  modelica_metatype _outArg = NULL;
20895  MMC_SO();
20896  _tailrecursive: OMC_LABEL_UNUSED
20897 #line 1477 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
20898  _outExp = omc_Absyn_traverseExpBidir(threadData, _inExp, ((modelica_fnptr) _inFunc), boxvar_Absyn_dummyTraverseExp, _inArg ,&_outArg);
20899 #line 20899 OMC_FILE
20900  _return: OMC_LABEL_UNUSED
20901  if (out_outArg) { *out_outArg = _outArg; }
20902  return _outExp;
20903 }
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
void * modelica_metatype
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_traverseListGeneric()

PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseListGeneric ( threadData_t threadData,
modelica_metatype  _inList,
modelica_fnptr  _inFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg,
modelica_boolean out_outContinue 
)

Definition at line 2920 of file Absyn.c.

2921 {
2922  modelica_metatype _outList = NULL;
2923  modelica_metatype _outArg = NULL;
2924  modelica_boolean _outContinue;
2925  modelica_boolean _eq;
2926  modelica_boolean _changed;
2927  modelica_metatype _e = NULL;
2928  modelica_metatype _new_e = NULL;
2929  modelica_metatype _rest_e = NULL;
2930  modelica_integer tmp1;
2931  modelica_metatype tmpMeta[4] __attribute__((unused)) = {0};
2932  MMC_SO();
2933  _tailrecursive: OMC_LABEL_UNUSED
2934  tmpMeta[0] = MMC_REFSTRUCTLIT(mmc_nil);
2935  _outList = tmpMeta[0];
2936  _outArg = _inArg;
2937  _outContinue = 1;
2938  _changed = 0;
2939  _rest_e = _inList;
2940 #line 6307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2941  while(1)
2942 #line 6307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2943  {
2944 #line 6307 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2945  if(!(!listEmpty(_rest_e))) break;
2946 #line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2947  /* Pattern-matching assignment */
2948 #line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2949  tmpMeta[1] = _rest_e;
2950 #line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2951  if (listEmpty(tmpMeta[1])) MMC_THROW_INTERNAL();
2952 #line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2953  tmpMeta[2] = MMC_CAR(tmpMeta[1]);
2954 #line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2955  tmpMeta[3] = MMC_CDR(tmpMeta[1]);
2956 #line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2957  _e = tmpMeta[2];
2958 #line 6308 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2959  _rest_e = tmpMeta[3];
2960 #line 2960 OMC_FILE
2961 
2962 #line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2963  /* Pattern-matching tuple assignment */
2964 #line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2965  tmpMeta[3] = (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))) ? ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 2))), _e, _outArg, &tmpMeta[1], &tmpMeta[2]) : ((modelica_metatype(*)(threadData_t*, modelica_metatype, modelica_metatype, modelica_metatype, modelica_metatype)) (MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(_inFunc), 1)))) (threadData, _e, _outArg, &tmpMeta[1], &tmpMeta[2]);
2966 #line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2967  _new_e = tmpMeta[3];
2968 #line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2969  tmp1 = mmc_unbox_integer(tmpMeta[2]);
2970 #line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2971  _outArg = tmpMeta[1];
2972 #line 6309 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2973  _outContinue = tmp1 /* pattern as ty=Boolean */;
2974 #line 2974 OMC_FILE
2975 
2976 #line 6310 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2977  _eq = referenceEq(_new_e, _e);
2978 #line 2978 OMC_FILE
2979 
2980 #line 6311 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2981  tmpMeta[1] = mmc_mk_cons((_eq?_e:_new_e), _outList);
2982 #line 6311 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2983  _outList = tmpMeta[1];
2984 #line 2984 OMC_FILE
2985 
2986 #line 6312 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2987  _changed = (_changed || (!_eq));
2988 #line 2988 OMC_FILE
2989 
2990 #line 6313 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2991  if((!_outContinue))
2992 #line 6313 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2993  {
2994 #line 6313 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
2995  break;
2996 #line 2996 OMC_FILE
2997  }
2998  }
2999 
3000 #line 6316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3001  if(_changed)
3002 #line 6316 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3003  {
3004 #line 6317 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3005  _outList = omc_List_append__reverse(threadData, _outList, _rest_e);
3006 #line 3006 OMC_FILE
3007  }
3008  else
3009  {
3010 #line 6319 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
3011  _outList = _inList;
3012 #line 3012 OMC_FILE
3013  }
3014  _return: OMC_LABEL_UNUSED
3015  if (out_outArg) { *out_outArg = _outArg; }
3016  if (out_outContinue) { *out_outContinue = _outContinue; }
3017  return _outList;
3018 }
m_integer modelica_integer
DLLExport modelica_metatype omc_List_append__reverse(threadData_t *threadData, modelica_metatype _inList1, modelica_metatype _inList2)
Definition: List.c:17948
signed char modelica_boolean
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
int line
Definition: de.c:117
Here is the caller graph for this function:

◆ omc_Absyn_traverseMatchCase()

DLLExport modelica_metatype omc_Absyn_traverseMatchCase ( threadData_t threadData,
modelica_metatype  _inMatchCase,
modelica_fnptr  _enterFunc,
modelica_fnptr  _exitFunc,
modelica_metatype  _inArg,
modelica_metatype out_outArg 
)

Definition at line 19169 of file Absyn.c.

19170 {
19171  modelica_metatype _outMatchCase = NULL;
19172  modelica_metatype _outArg = NULL;
19173  modelica_metatype tmpMeta[11] __attribute__((unused)) = {0};
19174  MMC_SO();
19175  _tailrecursive: OMC_LABEL_UNUSED
19176 #line 1996 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19177 
19178 #line 1996 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19179 
19180 #line 19180 OMC_FILE
19181  { /* match expression */
19182  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
19183  tmp4_1 = _inMatchCase;
19184  tmp4_2 = _inArg;
19185  {
19186  modelica_metatype _arg = NULL;
19187  modelica_metatype _pattern = NULL;
19188  modelica_metatype _result = NULL;
19189  modelica_metatype _info = NULL;
19190  modelica_metatype _resultInfo = NULL;
19191  modelica_metatype _pinfo = NULL;
19192  modelica_metatype _ldecls = NULL;
19193  modelica_metatype _cp = NULL;
19194  modelica_metatype _cmt = NULL;
19195  modelica_metatype _patternGuard = NULL;
19196  volatile mmc_switch_type tmp4;
19197  int tmp5;
19198  tmp4 = 0;
19199  for (; tmp4 < 2; tmp4++) {
19200  switch (MMC_SWITCH_CAST(tmp4)) {
19201  case 0: {
19202  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,9) == 0) goto tmp3_end;
19203  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19204  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
19205  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
19206  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
19207  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 6));
19208  tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 7));
19209  tmpMeta[8] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 8));
19210  tmpMeta[9] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 9));
19211  tmpMeta[10] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 10));
19212 
19213  _pattern = tmpMeta[2];
19214  _patternGuard = tmpMeta[3];
19215  _pinfo = tmpMeta[4];
19216  _ldecls = tmpMeta[5];
19217  _cp = tmpMeta[6];
19218  _result = tmpMeta[7];
19219  _resultInfo = tmpMeta[8];
19220  _cmt = tmpMeta[9];
19221  _info = tmpMeta[10];
19222  _arg = tmp4_2;
19223  /* Pattern matching succeeded */
19224 #line 2008 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19225  _pattern = omc_Absyn_traverseExpBidir(threadData, _pattern, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19226 #line 19226 OMC_FILE
19227 
19228 #line 2009 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19229  _patternGuard = omc_Absyn_traverseExpOptBidir(threadData, _patternGuard, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19230 #line 19230 OMC_FILE
19231 
19232 #line 2010 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19233  _cp = omc_Absyn_traverseClassPartBidir(threadData, _cp, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19234 #line 19234 OMC_FILE
19235 
19236 #line 2011 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19237  _result = omc_Absyn_traverseExpBidir(threadData, _result, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19238 #line 19238 OMC_FILE
19239 #line 2012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19240  tmpMeta[2] = mmc_mk_box10(3, &Absyn_Case_CASE__desc, _pattern, _patternGuard, _pinfo, _ldecls, _cp, _result, _resultInfo, _cmt, _info);
19241 #line 2012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19242  tmpMeta[0+0] = tmpMeta[2];
19243 #line 2012 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19244  tmpMeta[0+1] = _arg;
19245 #line 19245 OMC_FILE
19246  goto tmp3_done;
19247  }
19248  case 1: {
19249  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,6) == 0) goto tmp3_end;
19250  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
19251  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
19252  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
19253  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 5));
19254  tmpMeta[6] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 6));
19255  tmpMeta[7] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 7));
19256 
19257  _ldecls = tmpMeta[2];
19258  _cp = tmpMeta[3];
19259  _result = tmpMeta[4];
19260  _resultInfo = tmpMeta[5];
19261  _cmt = tmpMeta[6];
19262  _info = tmpMeta[7];
19263  _arg = tmp4_2;
19264  /* Pattern matching succeeded */
19265 #line 2018 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19266  _cp = omc_Absyn_traverseClassPartBidir(threadData, _cp, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19267 #line 19267 OMC_FILE
19268 
19269 #line 2019 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19270  _result = omc_Absyn_traverseExpBidir(threadData, _result, ((modelica_fnptr) _enterFunc), ((modelica_fnptr) _exitFunc), _arg ,&_arg);
19271 #line 19271 OMC_FILE
19272 #line 2020 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19273  tmpMeta[2] = mmc_mk_box7(4, &Absyn_Case_ELSE__desc, _ldecls, _cp, _result, _resultInfo, _cmt, _info);
19274 #line 2020 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19275  tmpMeta[0+0] = tmpMeta[2];
19276 #line 2020 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
19277  tmpMeta[0+1] = _arg;
19278 #line 19278 OMC_FILE
19279  goto tmp3_done;
19280  }
19281  }
19282  goto tmp3_end;
19283  tmp3_end: ;
19284  }
19285  goto goto_2;
19286  goto_2:;
19287  MMC_THROW_INTERNAL();
19288  goto tmp3_done;
19289  tmp3_done:;
19290  }
19291  }
19292  _outMatchCase = tmpMeta[0+0];
19293  _outArg = tmpMeta[0+1];
19294  _return: OMC_LABEL_UNUSED
19295  if (out_outArg) { *out_outArg = _outArg; }
19296  return _outMatchCase;
19297 }
float mmc_switch_type
PROTECTED_FUNCTION_STATIC modelica_metatype omc_Absyn_traverseClassPartBidir(threadData_t *threadData, modelica_metatype _cp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_outArg)
Definition: Absyn.c:19087
DLLExport modelica_metatype omc_Absyn_traverseExpBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20838
void * modelica_fnptr
DLLExport modelica_metatype omc_Absyn_traverseExpOptBidir(threadData_t *threadData, modelica_metatype _inExp, modelica_fnptr _enterFunc, modelica_fnptr _exitFunc, modelica_metatype _inArg, modelica_metatype *out_arg)
Definition: Absyn.c:20771
void * modelica_metatype
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Case_CASE__desc
ADD_METARECORD_DEFINITIONS struct record_description Absyn_Case_ELSE__desc
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:

◆ omc_Absyn_typeSpecDimensions()

DLLExport modelica_metatype omc_Absyn_typeSpecDimensions ( threadData_t threadData,
modelica_metatype  _inTypeSpec 
)

Definition at line 17194 of file Absyn.c.

17195 {
17196  modelica_metatype _outDimensions = NULL;
17197  modelica_metatype tmpMeta[3] __attribute__((unused)) = {0};
17198  MMC_SO();
17199  _tailrecursive: OMC_LABEL_UNUSED
17200 #line 17200 OMC_FILE
17201  { /* match expression */
17202  modelica_metatype tmp3_1;
17203  tmp3_1 = _inTypeSpec;
17204  {
17205  modelica_metatype _dim = NULL;
17206  volatile mmc_switch_type tmp3;
17207  int tmp4;
17208  tmp3 = 0;
17209  for (; tmp3 < 3; tmp3++) {
17210  switch (MMC_SWITCH_CAST(tmp3)) {
17211  case 0: {
17212  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
17213  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 3));
17214  if (optionNone(tmpMeta[1])) goto tmp2_end;
17215  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
17216  _dim = tmpMeta[2];
17217  /* Pattern matching succeeded */
17218 #line 2653 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17219  tmpMeta[0] = _dim;
17220 #line 17220 OMC_FILE
17221  goto tmp2_done;
17222  }
17223  case 1: {
17224  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
17225  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 4));
17226  if (optionNone(tmpMeta[1])) goto tmp2_end;
17227  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmpMeta[1]), 1));
17228  _dim = tmpMeta[2];
17229  /* Pattern matching succeeded */
17230 #line 2654 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17231  tmpMeta[0] = _dim;
17232 #line 17232 OMC_FILE
17233  goto tmp2_done;
17234  }
17235  case 2: {
17236 
17237  /* Pattern matching succeeded */
17238 #line 2655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17239  tmpMeta[1] = MMC_REFSTRUCTLIT(mmc_nil);
17240 #line 2655 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17241  tmpMeta[0] = tmpMeta[1];
17242 #line 17242 OMC_FILE
17243  goto tmp2_done;
17244  }
17245  }
17246  goto tmp2_end;
17247  tmp2_end: ;
17248  }
17249  goto goto_1;
17250  goto_1:;
17251  MMC_THROW_INTERNAL();
17252  goto tmp2_done;
17253  tmp2_done:;
17254  }
17255  }
17256  _outDimensions = tmpMeta[0];
17257  _return: OMC_LABEL_UNUSED
17258  return _outDimensions;
17259 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21

◆ omc_Absyn_typeSpecEqual()

DLLExport modelica_boolean omc_Absyn_typeSpecEqual ( threadData_t threadData,
modelica_metatype  _a,
modelica_metatype  _b 
)

Definition at line 17468 of file Absyn.c.

17469 {
17470  modelica_boolean _ob;
17471  modelica_boolean tmp1 = 0;
17472  modelica_metatype tmpMeta[6] __attribute__((unused)) = {0};
17473  MMC_SO();
17474  _tailrecursive: OMC_LABEL_UNUSED
17475 #line 17475 OMC_FILE
17476  { /* matchcontinue expression */
17477  volatile modelica_metatype tmp4_1;volatile modelica_metatype tmp4_2;
17478  tmp4_1 = _a;
17479  tmp4_2 = _b;
17480  {
17481  modelica_metatype _p1 = NULL;
17482  modelica_metatype _p2 = NULL;
17483  modelica_metatype _oad1 = NULL;
17484  modelica_metatype _oad2 = NULL;
17485  modelica_metatype _lst1 = NULL;
17486  modelica_metatype _lst2 = NULL;
17487  volatile mmc_switch_type tmp4;
17488  int tmp5;
17489  tmp4 = 0;
17490  MMC_TRY_INTERNAL(mmc_jumper)
17491  tmp3_top:
17492  threadData->mmc_jumper = &new_mmc_jumper;
17493  for (; tmp4 < 3; tmp4++) {
17494  switch (MMC_SWITCH_CAST(tmp4)) {
17495  case 0: {
17496  modelica_boolean tmp6;
17497  modelica_boolean tmp7;
17498  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
17499  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17500  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
17501  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,2) == 0) goto tmp3_end;
17502  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
17503  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
17504  _p1 = tmpMeta[0];
17505  _oad1 = tmpMeta[1];
17506  _p2 = tmpMeta[2];
17507  _oad2 = tmpMeta[3];
17508  tmp4 += 1; /* Pattern matching succeeded; we may skip some cases if we fail */
17509 #line 2590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17510  /* Pattern-matching assignment */
17511 #line 2590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17512  tmp6 = omc_Absyn_pathEqual(threadData, _p1, _p2);
17513 #line 2590 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17514  if (1 != tmp6) goto goto_2;
17515 #line 17515 OMC_FILE
17516 
17517 #line 2591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17518  /* Pattern-matching assignment */
17519 #line 2591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17520  tmp7 = omc_Absyn_optArrayDimEqual(threadData, _oad1, _oad2);
17521 #line 2591 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17522  if (1 != tmp7) goto goto_2;
17523 #line 17523 OMC_FILE
17524 #line 2592 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17525  tmp1 = 1;
17526 #line 17526 OMC_FILE
17527  goto tmp3_done;
17528  }
17529  case 1: {
17530  modelica_boolean tmp8;
17531  modelica_boolean tmp9;
17532  modelica_boolean tmp10;
17533  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
17534  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17535  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
17536  tmpMeta[2] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 4));
17537  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,3) == 0) goto tmp3_end;
17538  tmpMeta[3] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
17539  tmpMeta[4] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 3));
17540  tmpMeta[5] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 4));
17541  _p1 = tmpMeta[0];
17542  _lst1 = tmpMeta[1];
17543  _oad1 = tmpMeta[2];
17544  _p2 = tmpMeta[3];
17545  _lst2 = tmpMeta[4];
17546  _oad2 = tmpMeta[5];
17547  /* Pattern matching succeeded */
17548 #line 2596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17549  /* Pattern-matching assignment */
17550 #line 2596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17551  tmp8 = omc_Absyn_pathEqual(threadData, _p1, _p2);
17552 #line 2596 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17553  if (1 != tmp8) goto goto_2;
17554 #line 17554 OMC_FILE
17555 
17556 #line 2597 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17557  /* Pattern-matching assignment */
17558 #line 2597 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17559  tmp9 = omc_List_isEqualOnTrue(threadData, _lst1, _lst2, boxvar_Absyn_typeSpecEqual);
17560 #line 2597 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17561  if (1 != tmp9) goto goto_2;
17562 #line 17562 OMC_FILE
17563 
17564 #line 2598 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17565  /* Pattern-matching assignment */
17566 #line 2598 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17567  tmp10 = omc_Absyn_optArrayDimEqual(threadData, _oad1, _oad2);
17568 #line 2598 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17569  if (1 != tmp10) goto goto_2;
17570 #line 17570 OMC_FILE
17571 #line 2599 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17572  tmp1 = 1;
17573 #line 17573 OMC_FILE
17574  goto tmp3_done;
17575  }
17576  case 2: {
17577 
17578  /* Pattern matching succeeded */
17579 #line 2601 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17580  tmp1 = 0;
17581 #line 17581 OMC_FILE
17582  goto tmp3_done;
17583  }
17584  }
17585  goto tmp3_end;
17586  tmp3_end: ;
17587  }
17588  goto goto_2;
17589  tmp3_done:
17590  (void)tmp4;
17591  MMC_RESTORE_INTERNAL(mmc_jumper);
17592  goto tmp3_done2;
17593  goto_2:;
17594  MMC_CATCH_INTERNAL(mmc_jumper);
17595  if (++tmp4 < 3) {
17596  goto tmp3_top;
17597  }
17598  MMC_THROW_INTERNAL();
17599  tmp3_done2:;
17600  }
17601  }
17602  _ob = tmp1;
17603  _return: OMC_LABEL_UNUSED
17604  return _ob;
17605 }
GC_API void(GC_CALLBACK *GC_same_obj_print_proc)(void *
DLLExport modelica_boolean omc_Absyn_pathEqual(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:17616
signed char modelica_boolean
float mmc_switch_type
DLLExport modelica_boolean omc_List_isEqualOnTrue(threadData_t *threadData, modelica_metatype _inList1, modelica_metatype _inList2, modelica_fnptr _inCompFunc)
Definition: List.c:18331
void * modelica_metatype
DLLExport modelica_boolean omc_Absyn_optArrayDimEqual(threadData_t *threadData, modelica_metatype _oad1, modelica_metatype _oad2)
Definition: Absyn.c:17375
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
jmp_buf * mmc_jumper
Definition: omc_gc.h:119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_typeSpecPath()

DLLExport modelica_metatype omc_Absyn_typeSpecPath ( threadData_t threadData,
modelica_metatype  _tp 
)

Definition at line 17262 of file Absyn.c.

17263 {
17264  modelica_metatype _op = NULL;
17265  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
17266  MMC_SO();
17267  _tailrecursive: OMC_LABEL_UNUSED
17268 #line 17268 OMC_FILE
17269  { /* match expression */
17270  modelica_metatype tmp3_1;
17271  tmp3_1 = _tp;
17272  {
17273  modelica_metatype _p = NULL;
17274  volatile mmc_switch_type tmp3;
17275  int tmp4;
17276  tmp3 = 0;
17277  for (; tmp3 < 2; tmp3++) {
17278  switch (MMC_SWITCH_CAST(tmp3)) {
17279  case 0: {
17280  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,1,3) == 0) goto tmp2_end;
17281  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
17282 
17283  _p = tmpMeta[1];
17284  /* Pattern matching succeeded */
17285 #line 2639 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17286  tmpMeta[0] = _p;
17287 #line 17287 OMC_FILE
17288  goto tmp2_done;
17289  }
17290  case 1: {
17291  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,2) == 0) goto tmp2_end;
17292  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
17293 
17294  _p = tmpMeta[1];
17295  /* Pattern matching succeeded */
17296 #line 2640 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17297  tmpMeta[0] = _p;
17298 #line 17298 OMC_FILE
17299  goto tmp2_done;
17300  }
17301  }
17302  goto tmp2_end;
17303  tmp2_end: ;
17304  }
17305  goto goto_1;
17306  goto_1:;
17307  MMC_THROW_INTERNAL();
17308  goto tmp2_done;
17309  tmp2_done:;
17310  }
17311  }
17312  _op = tmpMeta[0];
17313  _return: OMC_LABEL_UNUSED
17314  return _op;
17315 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_typeSpecPathString()

DLLExport modelica_string omc_Absyn_typeSpecPathString ( threadData_t threadData,
modelica_metatype  _tp 
)

Definition at line 17318 of file Absyn.c.

17319 {
17320  modelica_string _s = NULL;
17321  modelica_string tmp1 = 0;
17322  modelica_metatype tmpMeta[1] __attribute__((unused)) = {0};
17323  MMC_SO();
17324  _tailrecursive: OMC_LABEL_UNUSED
17325 #line 17325 OMC_FILE
17326  { /* match expression */
17327  modelica_metatype tmp4_1;
17328  tmp4_1 = _tp;
17329  {
17330  modelica_metatype _p = NULL;
17331  volatile mmc_switch_type tmp4;
17332  int tmp5;
17333  tmp4 = 0;
17334  for (; tmp4 < 2; tmp4++) {
17335  switch (MMC_SWITCH_CAST(tmp4)) {
17336  case 0: {
17337  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
17338  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17339 
17340  _p = tmpMeta[0];
17341  /* Pattern matching succeeded */
17342 #line 2627 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17343  tmp1 = omc_Absyn_pathString(threadData, _p, _OMC_LIT1, 1, 0);
17344 #line 17344 OMC_FILE
17345  goto tmp3_done;
17346  }
17347  case 1: {
17348  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
17349  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
17350 
17351  _p = tmpMeta[0];
17352  /* Pattern matching succeeded */
17353 #line 2628 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
17354  tmp1 = omc_Absyn_pathString(threadData, _p, _OMC_LIT1, 1, 0);
17355 #line 17355 OMC_FILE
17356  goto tmp3_done;
17357  }
17358  }
17359  goto tmp3_end;
17360  tmp3_end: ;
17361  }
17362  goto goto_2;
17363  goto_2:;
17364  MMC_THROW_INTERNAL();
17365  goto tmp3_done;
17366  tmp3_done:;
17367  }
17368  }
17369  _s = tmp1;
17370  _return: OMC_LABEL_UNUSED
17371  return _s;
17372 }
modelica_metatype modelica_string
float mmc_switch_type
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_typeSpecString()

DLLExport modelica_string omc_Absyn_typeSpecString ( threadData_t threadData,
modelica_metatype  _inTs 
)

Definition at line 4378 of file Absyn.c.

4379 {
4380  modelica_string _outStr = NULL;
4381  MMC_SO();
4382  _tailrecursive: OMC_LABEL_UNUSED
4383 #line 5891 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4384  _outStr = omc_Dump_unparseTypeSpec(threadData, _inTs);
4385 #line 4385 OMC_FILE
4386  _return: OMC_LABEL_UNUSED
4387  return _outStr;
4388 }
modelica_metatype modelica_string
DLLExport modelica_string omc_Dump_unparseTypeSpec(threadData_t *threadData, modelica_metatype _inTypeSpec)
Definition: Dump.c:8806
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_typeSpecStringNoQualNoDims()

DLLExport modelica_string omc_Absyn_typeSpecStringNoQualNoDims ( threadData_t threadData,
modelica_metatype  _inTs 
)

Definition at line 4294 of file Absyn.c.

4295 {
4296  modelica_string _outStr = NULL;
4297  modelica_string tmp1 = 0;
4298  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
4299  MMC_SO();
4300  _tailrecursive: OMC_LABEL_UNUSED
4301 #line 4301 OMC_FILE
4302  { /* match expression */
4303  modelica_metatype tmp4_1;
4304  tmp4_1 = _inTs;
4305  {
4306  modelica_string _str1 = NULL;
4307  modelica_string _str2 = NULL;
4308  modelica_metatype _path = NULL;
4309  modelica_metatype _typeSpecLst = NULL;
4310  volatile mmc_switch_type tmp4;
4311  int tmp5;
4312  tmp4 = 0;
4313  for (; tmp4 < 2; tmp4++) {
4314  switch (MMC_SWITCH_CAST(tmp4)) {
4315  case 0: {
4316  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,2) == 0) goto tmp3_end;
4317  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4318 
4319  _path = tmpMeta[0];
4320  /* Pattern matching succeeded */
4321 #line 5914 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4322  tmp1 = omc_Absyn_pathString(threadData, omc_Absyn_makeNotFullyQualified(threadData, _path), _OMC_LIT1, 1, 0);
4323 #line 4323 OMC_FILE
4324  goto tmp3_done;
4325  }
4326  case 1: {
4327  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,3) == 0) goto tmp3_end;
4328  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
4329  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 3));
4330 
4331  _path = tmpMeta[0];
4332  _typeSpecLst = tmpMeta[1];
4333  /* Pattern matching succeeded */
4334 #line 5920 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4335  _str1 = omc_Absyn_pathString(threadData, omc_Absyn_makeNotFullyQualified(threadData, _path), _OMC_LIT1, 1, 0);
4336 #line 4336 OMC_FILE
4337 
4338 #line 5921 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4339  _str2 = omc_Absyn_typeSpecStringNoQualNoDimsLst(threadData, _typeSpecLst);
4340 #line 4340 OMC_FILE
4341 #line 5922 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4342  tmpMeta[0] = mmc_mk_cons(_str1, mmc_mk_cons(_OMC_LIT4, mmc_mk_cons(_str2, mmc_mk_cons(_OMC_LIT5, MMC_REFSTRUCTLIT(mmc_nil)))));
4343 #line 5922 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4344  tmp1 = stringAppendList(tmpMeta[0]);
4345 #line 4345 OMC_FILE
4346  goto tmp3_done;
4347  }
4348  }
4349  goto tmp3_end;
4350  tmp3_end: ;
4351  }
4352  goto goto_2;
4353  goto_2:;
4354  MMC_THROW_INTERNAL();
4355  goto tmp3_done;
4356  tmp3_done:;
4357  }
4358  }
4359  _outStr = tmp1;
4360  _return: OMC_LABEL_UNUSED
4361  return _outStr;
4362 }
modelica_metatype modelica_string
DLLExport modelica_string omc_Absyn_typeSpecStringNoQualNoDimsLst(threadData_t *threadData, modelica_metatype _inTypeSpecLst)
Definition: Absyn.c:4281
metamodelica_string stringAppendList(modelica_metatype lst)
float mmc_switch_type
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_makeNotFullyQualified(threadData_t *threadData, modelica_metatype _inPath)
Definition: Absyn.c:8283
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_typeSpecStringNoQualNoDimsLst()

DLLExport modelica_string omc_Absyn_typeSpecStringNoQualNoDimsLst ( threadData_t threadData,
modelica_metatype  _inTypeSpecLst 
)

Definition at line 4281 of file Absyn.c.

4282 {
4283  modelica_string _outString = NULL;
4284  MMC_SO();
4285  _tailrecursive: OMC_LABEL_UNUSED
4286 #line 5933 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
4287  _outString = omc_List_toString(threadData, _inTypeSpecLst, boxvar_Absyn_typeSpecStringNoQualNoDims, _OMC_LIT2, _OMC_LIT2, _OMC_LIT3, _OMC_LIT2, 0);
4288 #line 4288 OMC_FILE
4289  _return: OMC_LABEL_UNUSED
4290  return _outString;
4291 }
modelica_metatype modelica_string
DLLExport modelica_string omc_List_toString(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inPrintFunc, modelica_string _inListNameStr, modelica_string _inBeginStr, modelica_string _inDelimitStr, modelica_string _inEndStr, modelica_boolean _inPrintEmpty)
Definition: List.c:2057
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_unqotePathIdents()

DLLExport modelica_metatype omc_Absyn_unqotePathIdents ( threadData_t threadData,
modelica_metatype  _inPath 
)

Definition at line 7586 of file Absyn.c.

7587 {
7588  modelica_metatype _path = NULL;
7589  MMC_SO();
7590  _tailrecursive: OMC_LABEL_UNUSED
7591 #line 5144 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7592  _path = omc_Absyn_stringListPath(threadData, omc_List_map(threadData, omc_Absyn_pathToStringList(threadData, _inPath), boxvar_System_unquoteIdentifier));
7593 #line 7593 OMC_FILE
7594  _return: OMC_LABEL_UNUSED
7595  return _path;
7596 }
DLLExport modelica_metatype omc_Absyn_pathToStringList(threadData_t *threadData, modelica_metatype _path)
Definition: Absyn.c:14992
DLLExport modelica_metatype omc_List_map(threadData_t *threadData, modelica_metatype _inList, modelica_fnptr _inFunc)
Definition: List.c:13453
void * modelica_metatype
DLLExport modelica_metatype omc_Absyn_stringListPath(threadData_t *threadData, modelica_metatype _paths)
Definition: Absyn.c:16056
Here is the call graph for this function:

◆ omc_Absyn_unqualifyCref()

DLLExport modelica_metatype omc_Absyn_unqualifyCref ( threadData_t threadData,
modelica_metatype  _inCref 
)

Definition at line 7534 of file Absyn.c.

7535 {
7536  modelica_metatype _outCref = NULL;
7537  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
7538  MMC_SO();
7539  _tailrecursive: OMC_LABEL_UNUSED
7540 #line 7540 OMC_FILE
7541  { /* match expression */
7542  modelica_metatype tmp3_1;
7543  tmp3_1 = _inCref;
7544  {
7545  modelica_metatype _cref = NULL;
7546  volatile mmc_switch_type tmp3;
7547  int tmp4;
7548  tmp3 = 0;
7549  for (; tmp3 < 2; tmp3++) {
7550  switch (MMC_SWITCH_CAST(tmp3)) {
7551  case 0: {
7552  if (mmc__uniontype__metarecord__typedef__equal(tmp3_1,0,1) == 0) goto tmp2_end;
7553  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp3_1), 2));
7554  _cref = tmpMeta[1];
7555  /* Pattern matching succeeded */
7556 #line 5157 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7557  tmpMeta[0] = _cref;
7558 #line 7558 OMC_FILE
7559  goto tmp2_done;
7560  }
7561  case 1: {
7562 
7563  /* Pattern matching succeeded */
7564 #line 5158 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7565  tmpMeta[0] = _inCref;
7566 #line 7566 OMC_FILE
7567  goto tmp2_done;
7568  }
7569  }
7570  goto tmp2_end;
7571  tmp2_end: ;
7572  }
7573  goto goto_1;
7574  goto_1:;
7575  MMC_THROW_INTERNAL();
7576  goto tmp2_done;
7577  tmp2_done:;
7578  }
7579  }
7580  _outCref = tmpMeta[0];
7581  _return: OMC_LABEL_UNUSED
7582  return _outCref;
7583 }
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the caller graph for this function:

◆ omc_Absyn_withinEqual()

DLLExport modelica_boolean omc_Absyn_withinEqual ( threadData_t threadData,
modelica_metatype  _within1,
modelica_metatype  _within2 
)

Definition at line 7285 of file Absyn.c.

7286 {
7287  modelica_boolean _b;
7288  modelica_boolean tmp1 = 0;
7289  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
7290  MMC_SO();
7291  _tailrecursive: OMC_LABEL_UNUSED
7292 #line 7292 OMC_FILE
7293  { /* match expression */
7294  modelica_metatype tmp4_1;modelica_metatype tmp4_2;
7295  tmp4_1 = _within1;
7296  tmp4_2 = _within2;
7297  {
7298  modelica_metatype _p1 = NULL;
7299  modelica_metatype _p2 = NULL;
7300  volatile mmc_switch_type tmp4;
7301  int tmp5;
7302  tmp4 = 0;
7303  for (; tmp4 < 3; tmp4++) {
7304  switch (MMC_SWITCH_CAST(tmp4)) {
7305  case 0: {
7306  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
7307  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,1,0) == 0) goto tmp3_end;
7308  /* Pattern matching succeeded */
7309 #line 5200 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7310  tmp1 = 1;
7311 #line 7311 OMC_FILE
7312  goto tmp3_done;
7313  }
7314  case 1: {
7315  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
7316  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
7317  if (mmc__uniontype__metarecord__typedef__equal(tmp4_2,0,1) == 0) goto tmp3_end;
7318  tmpMeta[1] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_2), 2));
7319  _p1 = tmpMeta[0];
7320  _p2 = tmpMeta[1];
7321  /* Pattern matching succeeded */
7322 #line 5201 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7323  tmp1 = omc_Absyn_pathEqual(threadData, _p1, _p2);
7324 #line 7324 OMC_FILE
7325  goto tmp3_done;
7326  }
7327  case 2: {
7328 
7329  /* Pattern matching succeeded */
7330 #line 5202 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7331  tmp1 = 0;
7332 #line 7332 OMC_FILE
7333  goto tmp3_done;
7334  }
7335  }
7336  goto tmp3_end;
7337  tmp3_end: ;
7338  }
7339  goto goto_2;
7340  goto_2:;
7341  MMC_THROW_INTERNAL();
7342  goto tmp3_done;
7343  tmp3_done:;
7344  }
7345  }
7346  _b = tmp1;
7347  _return: OMC_LABEL_UNUSED
7348  return _b;
7349 }
DLLExport modelica_boolean omc_Absyn_pathEqual(threadData_t *threadData, modelica_metatype _inPath1, modelica_metatype _inPath2)
Definition: Absyn.c:17616
signed char modelica_boolean
float mmc_switch_type
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21
Here is the call graph for this function:
Here is the caller graph for this function:

◆ omc_Absyn_withinString()

DLLExport modelica_string omc_Absyn_withinString ( threadData_t threadData,
modelica_metatype  _w1 
)

Definition at line 7228 of file Absyn.c.

7229 {
7230  modelica_string _str = NULL;
7231  modelica_string tmp1 = 0;
7232  modelica_metatype tmpMeta[2] __attribute__((unused)) = {0};
7233  MMC_SO();
7234  _tailrecursive: OMC_LABEL_UNUSED
7235 #line 7235 OMC_FILE
7236  { /* match expression */
7237  modelica_metatype tmp4_1;
7238  tmp4_1 = _w1;
7239  {
7240  modelica_metatype _p1 = NULL;
7241  volatile mmc_switch_type tmp4;
7242  int tmp5;
7243  tmp4 = 0;
7244  for (; tmp4 < 2; tmp4++) {
7245  switch (MMC_SWITCH_CAST(tmp4)) {
7246  case 0: {
7247  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,1,0) == 0) goto tmp3_end;
7248  /* Pattern matching succeeded */
7249 #line 5213 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7250  tmp1 = _OMC_LIT12;
7251 #line 7251 OMC_FILE
7252  goto tmp3_done;
7253  }
7254  case 1: {
7255  if (mmc__uniontype__metarecord__typedef__equal(tmp4_1,0,1) == 0) goto tmp3_end;
7256  tmpMeta[0] = MMC_FETCH(MMC_OFFSET(MMC_UNTAGPTR(tmp4_1), 2));
7257  _p1 = tmpMeta[0];
7258  /* Pattern matching succeeded */
7259 #line 5214 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7260  tmpMeta[0] = stringAppend(_OMC_LIT13,omc_Absyn_pathString(threadData, _p1, _OMC_LIT1, 1, 0));
7261 #line 5214 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7262  tmpMeta[1] = stringAppend(tmpMeta[0],_OMC_LIT14);
7263 #line 5214 "/omcompiler/Compiler/FrontEnd/Absyn.mo"
7264  tmp1 = tmpMeta[1];
7265 #line 7265 OMC_FILE
7266  goto tmp3_done;
7267  }
7268  }
7269  goto tmp3_end;
7270  tmp3_end: ;
7271  }
7272  goto goto_2;
7273  goto_2:;
7274  MMC_THROW_INTERNAL();
7275  goto tmp3_done;
7276  tmp3_done:;
7277  }
7278  }
7279  _str = tmp1;
7280  _return: OMC_LABEL_UNUSED
7281  return _str;
7282 }
modelica_metatype modelica_string
float mmc_switch_type
DLLExport modelica_string omc_Absyn_pathString(threadData_t *threadData, modelica_metatype _path, modelica_string _delimiter, modelica_boolean _usefq, modelica_boolean _reverse)
Definition: Absyn.c:17021
modelica_string stringAppend(modelica_string s1, modelica_string s2)
void * modelica_metatype
unsigned long AO_t __attribute__((aligned(4)))
Definition: m68k.h:21